From a8ec17c700ce757545292193b6d9a3c75f496626 Mon Sep 17 00:00:00 2001 From: Toby Hede Date: Tue, 14 Jul 2026 12:48:08 +1000 Subject: [PATCH 01/19] feat(eql_v3): add storage-only public.eql_v3_json; rename JSON family for consistency MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Make the encrypted-JSON domains follow the same naming convention as every scalar family: the bare family name is the storage-only domain, a suffix marks the searchable variant. - New: public.eql_v3_json — a ciphertext-only, storage-only encrypted-JSON domain ({v,i,c}, no index terms; the JSON analogue of public.eql_v3_boolean), generated by the scalar materializer like any storage-only scalar. - Renamed (3.0.0-alpha surface): the searchable SteVec document public.eql_v3_json -> public.eql_v3_json_search, public.eql_v3_jsonb_entry -> public.eql_v3_json_entry, eql_v3.query_jsonb -> eql_v3.query_json. The `json` family is now a mixed family: three hand-written SteVec domains plus one generated scalar storage domain. eql-codegen's SQL/bindings drivers iterate a new families_with_scalar_domains() seam and render each family's scalar domains only; the family stays non-scalar so scalar_families() (list-types, the matrix) still excludes it. The generated Json struct is re-exported from the hand-written json.rs so inventory/payload resolve super::json::Json. Regenerated SQL/bindings/TS/JSON committed; changeset + U-007 upgrade note added. --- .changeset/json-storage-and-search-rename.md | 5 + CLAUDE.md | 8 +- crates/eql-bindings/bindings/v3/Json.ts | 11 + crates/eql-bindings/bindings/v3/Selector.ts | 2 +- .../bindings/v3/SteVecDocument.ts | 2 +- .../eql-bindings/bindings/v3/SteVecEntry.ts | 2 +- .../eql-bindings/bindings/v3/SteVecQuery.ts | 2 +- .../eql-bindings/schema/v3/eql_v3_json.json | 82 +--- ...sonb_entry.json => eql_v3_json_entry.json} | 6 +- .../schema/v3/eql_v3_json_search.json | 124 ++++++ .../v3/{query_jsonb.json => query_json.json} | 6 +- crates/eql-bindings/src/from_v2/error.rs | 4 +- crates/eql-bindings/src/from_v2/mod.rs | 24 +- crates/eql-bindings/src/from_v2/target.rs | 12 +- crates/eql-bindings/src/v3/domain_type.rs | 4 +- crates/eql-bindings/src/v3/inventory.rs | 7 +- .../eql-bindings/src/v3/{jsonb.rs => json.rs} | 24 +- crates/eql-bindings/src/v3/json_storage.rs | 39 ++ crates/eql-bindings/src/v3/mod.rs | 19 +- crates/eql-bindings/src/v3/payload.rs | 10 +- crates/eql-bindings/src/v3/query_payload.rs | 8 +- crates/eql-bindings/src/v3/terms.rs | 2 +- crates/eql-bindings/tests/catalog_parity.rs | 46 +- crates/eql-bindings/tests/domain_payload.rs | 14 +- crates/eql-bindings/tests/from_v2.rs | 8 +- crates/eql-bindings/tests/query_payload.rs | 22 +- crates/eql-bindings/tests/v3_conformance.rs | 24 +- crates/eql-codegen/src/bindings.rs | 129 +++++- crates/eql-codegen/src/dump.rs | 76 ++-- crates/eql-codegen/src/generate.rs | 57 ++- crates/eql-codegen/tests/cli.rs | 7 +- crates/eql-codegen/tests/parity.rs | 11 +- crates/eql-domains/src/fixtures/mod.rs | 2 +- crates/eql-domains/src/fixtures/record.rs | 10 +- crates/eql-domains/src/lib.rs | 142 ++++-- crates/eql-domains/src/spec.rs | 93 ++-- crates/eql-domains/src/tests.rs | 46 +- .../adding-a-scalar-encrypted-domain-type.md | 30 +- docs/reference/catalog-driven-architecture.md | 6 +- docs/reference/database-indexes.md | 14 +- docs/reference/eql-functions.md | 18 +- docs/reference/json-support.md | 50 +-- docs/reference/permissions.md | 8 +- docs/reference/query-performance.md | 2 +- docs/reference/sql-support.md | 26 +- docs/tutorials/proxy-configuration.md | 14 +- docs/upgrading/v3.0.md | 86 +++- packages/eql/src/generated/schema-manifest.ts | 10 +- .../src/generated/schema/v3/eql_v3_json.json | 82 +--- ...sonb_entry.json => eql_v3_json_entry.json} | 6 +- .../schema/v3/eql_v3_json_search.json | 124 ++++++ .../v3/{query_jsonb.json => query_json.json} | 6 +- packages/eql/src/generated/v3/Json.ts | 11 + packages/eql/src/generated/v3/Selector.ts | 2 +- .../eql/src/generated/v3/SteVecDocument.ts | 2 +- packages/eql/src/generated/v3/SteVecEntry.ts | 2 +- packages/eql/src/generated/v3/SteVecQuery.ts | 2 +- packages/eql/src/generated/v3/index.ts | 1 + src/v3/{jsonb => json}/aggregates.sql | 56 +-- src/v3/{jsonb => json}/blockers.sql | 220 +++++----- src/v3/{jsonb => json}/functions.sql | 54 +-- src/v3/{jsonb => json}/operators.sql | 176 ++++---- src/v3/{jsonb => json}/types.sql | 56 +-- src/v3/scalars/json/json_functions.sql | 403 ++++++++++++++++++ src/v3/scalars/json/json_operators.sql | 227 ++++++++++ src/v3/scalars/json/json_types.sql | 26 ++ .../sqlx/snapshots/eql_v3_public_surface.txt | 48 +-- tests/sqlx/src/fixtures/eql_plaintext.rs | 2 +- tests/sqlx/src/fixtures/v3_convert.rs | 2 +- tests/sqlx/src/fixtures/v3_doc_integer.rs | 4 +- tests/sqlx/src/fixtures/v3_ste_vec.rs | 8 +- tests/sqlx/src/fixtures/validation.rs | 8 +- tests/sqlx/src/jsonb_entry.rs | 14 +- tests/sqlx/src/matrix.rs | 4 +- tests/sqlx/src/scalar_domains.rs | 6 +- tests/sqlx/tests/build_validation_tests.rs | 2 +- .../encrypted_domain/family/jsonb_check.rs | 176 +++++++- .../tests/encrypted_domain/family/support.rs | 6 +- .../tests/encrypted_domain/jsonb_entry.rs | 30 +- tests/sqlx/tests/payload_schema_tests.rs | 8 +- tests/sqlx/tests/v3_jsonb_bindings_tests.rs | 6 +- .../tests/v3_jsonb_operator_surface_tests.rs | 218 +++++----- tests/sqlx/tests/v3_jsonb_tests.rs | 246 +++++------ .../tests/v3_operator_equivalents_tests.rs | 6 +- tests/sqlx/tests/v3_privilege_tests.rs | 12 +- tests/sqlx/tests/v3_public_surface_tests.rs | 4 +- tests/sqlx/tests/v3_uninstall_tests.rs | 26 +- 87 files changed, 2472 insertions(+), 1174 deletions(-) create mode 100644 .changeset/json-storage-and-search-rename.md create mode 100644 crates/eql-bindings/bindings/v3/Json.ts rename crates/eql-bindings/schema/v3/{eql_v3_jsonb_entry.json => eql_v3_json_entry.json} (80%) create mode 100644 crates/eql-bindings/schema/v3/eql_v3_json_search.json rename crates/eql-bindings/schema/v3/{query_jsonb.json => query_json.json} (90%) rename crates/eql-bindings/src/v3/{jsonb.rs => json.rs} (84%) create mode 100644 crates/eql-bindings/src/v3/json_storage.rs rename packages/eql/src/generated/schema/v3/{eql_v3_jsonb_entry.json => eql_v3_json_entry.json} (80%) create mode 100644 packages/eql/src/generated/schema/v3/eql_v3_json_search.json rename packages/eql/src/generated/schema/v3/{query_jsonb.json => query_json.json} (90%) create mode 100644 packages/eql/src/generated/v3/Json.ts rename src/v3/{jsonb => json}/aggregates.sql (71%) rename src/v3/{jsonb => json}/blockers.sql (72%) rename src/v3/{jsonb => json}/functions.sql (90%) rename src/v3/{jsonb => json}/operators.sql (65%) rename src/v3/{jsonb => json}/types.sql (82%) create mode 100644 src/v3/scalars/json/json_functions.sql create mode 100644 src/v3/scalars/json/json_operators.sql create mode 100644 src/v3/scalars/json/json_types.sql diff --git a/.changeset/json-storage-and-search-rename.md b/.changeset/json-storage-and-search-rename.md new file mode 100644 index 000000000..b9f3b7f91 --- /dev/null +++ b/.changeset/json-storage-and-search-rename.md @@ -0,0 +1,5 @@ +--- +'@cipherstash/eql': minor +--- + +**The encrypted-JSON domains are renamed for a consistent `public.eql_v3_json` family, and a new ciphertext-only storage domain is added.** The bare name `public.eql_v3_json` is now a **storage-only** domain (a single opaque ciphertext, `{v,i,c}` envelope, no index terms — the JSON analogue of `public.eql_v3_boolean`, for encrypt-at-rest with no server-side searchability). The searchable SteVec document that previously held the bare `public.eql_v3_json` name is renamed to `public.eql_v3_json_search`; its supporting domains follow: `public.eql_v3_jsonb_entry` → `public.eql_v3_json_entry`, and the containment needle `eql_v3.query_jsonb` → `eql_v3.query_json`. This makes the JSON family follow the same convention as every scalar family — the bare family name is the storage-only domain and a suffix (`_search`, mirroring text's `_search`) marks the searchable variant. Reach for `public.eql_v3_json_search` when you need containment/field queries over encrypted JSON (`@>`, path access) and `public.eql_v3_json` when you only need to store and round-trip an encrypted JSON value. Callers on the previous names must update column declarations and query casts (`WHERE doc @> $1::eql_v3.query_json`); the bindings, `DomainPayload`/`QueryPayload` parse names, and published JSON Schema file names all move to the new names. diff --git a/CLAUDE.md b/CLAUDE.md index d76e35f79..60e448afa 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -49,7 +49,7 @@ This is the **Encrypt Query Language (EQL)** - a PostgreSQL extension for search ### Directory Structure - `src/` - contains only the self-contained `v3` surface (the modular `eql_v2` component directories were removed in 3.0.0) - `crates/` - Rust workspace: `eql-domains` (the catalog), `eql-codegen` (SQL/bindings generator), `eql-bindings` (payload bindings), `eql-tests-macros` -- `src/v3/` - Self-contained `eql_v3` / `eql_v3_internal` surface: `src/v3/schema.sql` (creates both schemas), forked `src/v3/crypto.sql` / `src/v3/common.sql`, hand-written SEM index-term types under `src/v3/sem/` (`hmac_256`, `ore_block_256`) — now created in `eql_v3_internal` — the generated scalar encrypted-domain families under `src/v3/scalars//` (user-column domains in `public`; extractors **and the supported comparison wrappers** in `eql_v3`; only the blockers and aggregate state functions in `eql_v3_internal`; plus the shared blocker `src/v3/scalars/functions.sql`), and the hand-written encrypted-JSONB (SteVec) surface under `src/v3/jsonb/` (`types.sql`, `functions.sql`, `operators.sql`, `aggregates.sql`, `blockers.sql` — the `public.eql_v3_json` / `public.eql_v3_jsonb_entry` column domains and their CHECK validators live in `public`, while the containment needle `eql_v3.query_jsonb` — a query operand, never a column type — lives in `eql_v3` (CIP-3442); typed operators, `jsonb_entry` comparison wrappers, the containment engine (`ste_vec_contains`), and raw-jsonb GIN helpers (`jsonb_array` / `jsonb_contains` / `jsonb_contained_by`) live in `eql_v3`; only the `is_ste_vec_array` helper and aggregate state functions live in `eql_v3_internal`) +- `src/v3/` - Self-contained `eql_v3` / `eql_v3_internal` surface: `src/v3/schema.sql` (creates both schemas), forked `src/v3/crypto.sql` / `src/v3/common.sql`, hand-written SEM index-term types under `src/v3/sem/` (`hmac_256`, `ore_block_256`) — now created in `eql_v3_internal` — the generated scalar encrypted-domain families under `src/v3/scalars//` (user-column domains in `public`; extractors **and the supported comparison wrappers** in `eql_v3`; only the blockers and aggregate state functions in `eql_v3_internal`; plus the shared blocker `src/v3/scalars/functions.sql`), and the hand-written encrypted-JSONB (SteVec) surface under `src/v3/json/` (`types.sql`, `functions.sql`, `operators.sql`, `aggregates.sql`, `blockers.sql` — the `public.eql_v3_json_search` / `public.eql_v3_json_entry` column domains and their CHECK validators live in `public`, while the containment needle `eql_v3.query_json` — a query operand, never a column type — lives in `eql_v3` (CIP-3442); typed operators, `json_entry` comparison wrappers, the containment engine (`ste_vec_contains`), and raw-jsonb GIN helpers (`jsonb_array` / `jsonb_contains` / `jsonb_contained_by`) live in `eql_v3`; only the `is_ste_vec_array` helper and aggregate state functions live in `eql_v3_internal`) - `tasks/` - mise task scripts - `tests/sqlx/` - Rust/SQLx test framework (PostgreSQL 14-17 support) - `release/` - Generated SQL installation files @@ -63,11 +63,11 @@ This is the **Encrypt Query Language (EQL)** - a PostgreSQL extension for search ### Encrypted-Domain Types -`src/v3/scalars/` holds the generated **encrypted-domain type families** — jsonb-backed PostgreSQL domains in the **`public` schema**, one domain per operator/index capability (`public.` storage-only, `public._eq`, `public._ord`), plus an `eql_v3.query__` **query-operand twin** per term-bearing domain (index-terms-only, no ciphertext `c`; in `eql_v3`, not `public`, because a query operand is never a column type — CIP-3442). The domains are `public.eql_v3_integer`, `public.eql_v3_integer_eq`, `public.eql_v3_integer_ord`, `public.eql_v3_integer_ord_ore`; their extractors (`eql_v3.eq_term`, `eql_v3.ord_term`), aggregates (`eql_v3.min`/`max`), **and the supported comparison wrappers** (`eq`/`neq`/`lt`/`lte`/`gt`/`gte`/`contains`/`contained_by`) all live in **`eql_v3`** — the wrappers are public so every operator has a callable function equivalent (Supabase/PostgREST). Only the **blockers** (for unsupported operators — they just raise), the **aggregate state functions**, and the SEM index-term types the extractors/wrappers return and construct (`eql_v3_internal.hmac_256`, `eql_v3_internal.ore_block_256`) live in **`eql_v3_internal`** — hand-written under `src/v3/sem/`, schema-qualified via the codegen's `INTERNAL_SCHEMA` constant for the generated surface (the codegen's `SCHEMA` constant qualifies the public wrappers; the `operator_entry` renderer picks the backing function's schema by whether the operator is supported) — so the whole v3 surface (both schemas together) is self-contained (no `eql_v2.` appears anywhere in v3 SQL; CI gates this via `mise run test:self_contained_v3` and the self-contained `release/cipherstash-encrypt.sql` installer). `public.eql_v3_integer` (PR #239, supersedes #225) is the reference scalar implementation; the catalog now generates a full surface for `integer`, `smallint`, `bigint`, `date`, `timestamp`, `numeric`, `text`, `boolean`, `real`, and `double`, all following this materializer pattern. `jsonb` is a `CATALOG` family too, but a permanently **hand-written**, not generated, one: its three domains (`public.eql_v3_json` document, `public.eql_v3_jsonb_entry`, `eql_v3.query_jsonb`) carry `Shape::SteVecDocument` / `SteVecEntry` / `SteVecQuery` (the `Shape` enum in `crates/eql-domains/src/lib.rs`) instead of `Shape::Scalar`, and their SQL lives under `src/v3/jsonb/` rather than `src/v3/scalars//` — `eql-codegen` renders SQL only for `scalar_families()` (the `Shape::Scalar` rows), so the fixed-envelope ordered-scalar materializer described below never touches `jsonb`. This is a deliberate, permanent split, not a gap awaiting a future generator. +`src/v3/scalars/` holds the generated **encrypted-domain type families** — jsonb-backed PostgreSQL domains in the **`public` schema**, one domain per operator/index capability (`public.` storage-only, `public._eq`, `public._ord`), plus an `eql_v3.query__` **query-operand twin** per term-bearing domain (index-terms-only, no ciphertext `c`; in `eql_v3`, not `public`, because a query operand is never a column type — CIP-3442). The domains are `public.eql_v3_integer`, `public.eql_v3_integer_eq`, `public.eql_v3_integer_ord`, `public.eql_v3_integer_ord_ore`; their extractors (`eql_v3.eq_term`, `eql_v3.ord_term`), aggregates (`eql_v3.min`/`max`), **and the supported comparison wrappers** (`eq`/`neq`/`lt`/`lte`/`gt`/`gte`/`contains`/`contained_by`) all live in **`eql_v3`** — the wrappers are public so every operator has a callable function equivalent (Supabase/PostgREST). Only the **blockers** (for unsupported operators — they just raise), the **aggregate state functions**, and the SEM index-term types the extractors/wrappers return and construct (`eql_v3_internal.hmac_256`, `eql_v3_internal.ore_block_256`) live in **`eql_v3_internal`** — hand-written under `src/v3/sem/`, schema-qualified via the codegen's `INTERNAL_SCHEMA` constant for the generated surface (the codegen's `SCHEMA` constant qualifies the public wrappers; the `operator_entry` renderer picks the backing function's schema by whether the operator is supported) — so the whole v3 surface (both schemas together) is self-contained (no `eql_v2.` appears anywhere in v3 SQL; CI gates this via `mise run test:self_contained_v3` and the self-contained `release/cipherstash-encrypt.sql` installer). `public.eql_v3_integer` (PR #239, supersedes #225) is the reference scalar implementation; the catalog now generates a full surface for `integer`, `smallint`, `bigint`, `date`, `timestamp`, `numeric`, `text`, `boolean`, `real`, and `double`, all following this materializer pattern. `json` is a `CATALOG` family too, but a **mixed** one: its three SteVec domains (`public.eql_v3_json_search` document, `public.eql_v3_json_entry`, `eql_v3.query_json`) carry `Shape::SteVec` (the `Shape` enum in `crates/eql-domains/src/lib.rs` has two variants, `Scalar` and `SteVec`; the three SteVec domains are disambiguated by `Domain.name`, not distinct variants) instead of `Shape::Scalar`, and their SQL lives permanently hand-written under `src/v3/json/` rather than `src/v3/scalars//`. Alongside them the family carries **one generated `Shape::Scalar` storage domain**, `public.eql_v3_json` (bare `name: ""`, ciphertext-only, no index terms — the JSON analogue of `public.eql_v3_boolean`), which the scalar materializer renders into `src/v3/scalars/json/` like every other storage-only domain. `eql-codegen`'s SQL/bindings drivers iterate `families_with_scalar_domains()` (families with ≥1 scalar domain) and render each family's scalar domains only — so a fully-scalar family is unchanged, `json`'s scalar storage domain is generated, and its hand-written SteVec domains are skipped (the family stays non-scalar because `is_scalar()` is `.all()`, so `scalar_families()` still excludes it wholesale). The searchable SteVec surface is a deliberate, permanent hand-written split, not a gap awaiting a future generator; only the ciphertext-only storage domain is materialized. -Adding a scalar encrypted-domain type is one row in the Rust catalog `eql-domains::CATALOG` (`crates/eql-domains/src/lib.rs`): a `DomainFamily` giving the type `name` (e.g. `bigint`), its `ScalarKind` (the `kind` field), the `Domain`s mapping each generated (bare) domain name to its fixed index `Term`s (`eq => [Hm]`, `ord`/`ord_ore => [Ore]`), and the `Fixture` value list. Term capabilities are fixed in the `Term` enum's `impl` methods (with unit tests): `Hm` provides equality, and `Ore` provides equality plus ordering. There is no TOML manifest and no Python — the catalog is the source of truth, validated by the compiler (an undefined term or unknown scalar is a compile error) plus catalog `#[test]`s. `mise run build` runs `cargo run -p eql-codegen`, which regenerates the scalar SQL surface into `src/v3/scalars//` from `CATALOG` at the start of every build; that surface includes supported comparison wrappers plus blockers for native `jsonb` operators that would otherwise be reachable through domain fallback. `cargo run -p eql-codegen` regenerates every type at once (the same call `mise run build` uses; there is no per-type codegen task). The generated `*_types.sql` / `*_functions.sql` / `*_operators.sql` / `*_aggregates.sql` files are **committed in place** under `src/v3/scalars//` and drift-gated by `mise run codegen:parity` (regenerate in place + `git diff` + untracked check — the same regenerate-and-diff pattern `types:check` uses for the committed bindings). They are still machine-generated: change the catalog and rebuild, never hand-edit (CI fails on drift). The per-type plaintext fixture lists the SQLx matrix consumes are **not** a generated file — they are materialised from each `CATALOG` row at compile time as `eql_domains::INT4_VALUES` / `INT2_VALUES` (the `int_values!` macro) and read directly by `ScalarType::FIXTURE_VALUES`; a Rust source of truth no longer round-trips through a committed generated `.rs`. Generated SQL carries a `-- AUTOMATICALLY GENERATED FILE` header (the project-wide marker `docs:validate` greps on); change the catalog and rebuild, never hand-edit. Hand-written SQL beyond the fixed surface goes in `src/v3/scalars//_extensions.sql` with no auto-generated header and explicit `-- REQUIRE:` edges — that file IS committed. `jsonb` (see above) never enters this pipeline: every consumer here (`generate_all`, `list-types`, the SQLx matrix) iterates `eql_domains::scalar_families()`, which excludes any non-`Shape::Scalar` row, so `jsonb` is invisible to the materializer and the matrix by construction, not by a per-type exception. +Adding a scalar encrypted-domain type is one row in the Rust catalog `eql-domains::CATALOG` (`crates/eql-domains/src/lib.rs`): a `DomainFamily` giving the type `name` (e.g. `bigint`), its `ScalarKind` (the `kind` field), the `Domain`s mapping each generated (bare) domain name to its fixed index `Term`s (`eq => [Hm]`, `ord`/`ord_ore => [Ore]`), and the `Fixture` value list. Term capabilities are fixed in the `Term` enum's `impl` methods (with unit tests): `Hm` provides equality, and `Ore` provides equality plus ordering. There is no TOML manifest and no Python — the catalog is the source of truth, validated by the compiler (an undefined term or unknown scalar is a compile error) plus catalog `#[test]`s. `mise run build` runs `cargo run -p eql-codegen`, which regenerates the scalar SQL surface into `src/v3/scalars//` from `CATALOG` at the start of every build; that surface includes supported comparison wrappers plus blockers for native `json` operators that would otherwise be reachable through domain fallback. `cargo run -p eql-codegen` regenerates every type at once (the same call `mise run build` uses; there is no per-type codegen task). The generated `*_types.sql` / `*_functions.sql` / `*_operators.sql` / `*_aggregates.sql` files are **committed in place** under `src/v3/scalars//` and drift-gated by `mise run codegen:parity` (regenerate in place + `git diff` + untracked check — the same regenerate-and-diff pattern `types:check` uses for the committed bindings). They are still machine-generated: change the catalog and rebuild, never hand-edit (CI fails on drift). The per-type plaintext fixture lists the SQLx matrix consumes are **not** a generated file — they are materialised from each `CATALOG` row at compile time as `eql_domains::INT4_VALUES` / `INT2_VALUES` (the `int_values!` macro) and read directly by `ScalarType::FIXTURE_VALUES`; a Rust source of truth no longer round-trips through a committed generated `.rs`. Generated SQL carries a `-- AUTOMATICALLY GENERATED FILE` header (the project-wide marker `docs:validate` greps on); change the catalog and rebuild, never hand-edit. Hand-written SQL beyond the fixed surface goes in `src/v3/scalars//_extensions.sql` with no auto-generated header and explicit `-- REQUIRE:` edges — that file IS committed. `json`'s **SteVec** domains never enter this pipeline, but its **scalar storage domain does**: `generate_all` iterates `eql_domains::families_with_scalar_domains()` and renders each family's scalar domains (so `public.eql_v3_json` is generated into `src/v3/scalars/json/`), while `list-types` and the SQLx matrix still iterate `eql_domains::scalar_families()`, which excludes the whole non-scalar `json` family — so `json` stays out of the operator/coverage matrix by construction (a storage-only domain carries no operator matrix), even though its ciphertext-only storage domain now has a generated SQL surface. -The same generator also emits the **Rust payload bindings** under `crates/eql-bindings/src/v3/.rs` (structs + `DomainType` impls) and the `inventory.rs` `all()` list, from the same `CATALOG` — committed with a `// @generated` header (the bindings must exist on a clean clone because `ts-rs`/`schemars` derive the committed TypeScript/JSON Schema off them; the SQL surface is now committed too, so both generated targets are handled consistently — committed in place, drift-gated by regenerate-and-`git diff`). The hand-written `DomainType` trait, the shared newtypes (`SchemaVersion`/`Identifier`/`Ciphertext`/`Hmac256`/`OreBlock256`/`BloomFilter`), the `PhantomData` plumbing, and the architectural module doc (including the non-derivable float-NaN and bool storage-only caveats) stay hand-written in `crates/eql-bindings/src/v3/{mod,domain_type,terms}.rs`. Generated structs carry a catalog-derived struct doc — a summary line (`` `eql_v3.` — . ``) plus a detail line listing the supported operators and required payload keys, all derived from data the catalog already holds (the capability label, `Term::operators_for_terms`, and `ENVELOPE_KEYS` ++ `Term::term_json_keys` — see `struct_doc_lines` in `crates/eql-codegen/src/bindings.rs`). The required-key list makes structural distinctions visible — e.g. `text_ord` lists `` `v` `i` `c` `hm` `ob` `` (dual-term) versus an integer `integer_ord`'s `` `v` `i` `c` `ob` ``. There are **no per-field docs**: per-field/term semantics live on the shared term newtypes (`terms.rs`, flowing into the TS term files and JSON Schema `$defs`), and non-derivable per-family caveats (float-NaN, bool storage-only) in `mod.rs`. Free-form prose belongs at the **struct level** (a future optional catalog `doc` field emitted as extra `#[doc]` lines), never as per-field docs. JSON Schemas are emitted by **schemars 1.x** as JSON Schema 2020-12. `mise run types:generate` regenerates the Rust bindings (via `eql-codegen bindings`) then the TS/JSON; `mise run types:check` is the committed-reference drift gate — it regenerates and `git diff`s all three (`crates/eql-bindings/src/v3` + `bindings/` + `schema/`), the same regenerate-and-diff pattern `codegen:parity` now uses for the committed SQL surface. Both gates run in CI; `mise run install-hooks` wires a pre-commit hook that runs both locally whenever a commit touches the catalog, the generator, or a committed generated surface. The `jsonb` family's own structs (`SteVecDocument`/`SteVecEntry`/`SteVecQuery`, plus the shared `SteVecTerm`/`SteVecQueryEntry`/`OreCllw`/`Selector` newtypes) are hand-written for the same reason as its SQL — in `crates/eql-bindings/src/v3/jsonb.rs`, symmetric with `src/v3/jsonb/` — their field layout (`#[serde(flatten)]`, an `Option` array marker, per-struct serde strictness) isn't derivable from the catalog the way a flat scalar struct is. Only inventory membership and ordering are catalog-driven: `inventory.rs::all()` iterates the full `CATALOG` (not `scalar_families()`), branching on `Shape` to include the three jsonb structs alongside the generated ones. +The same generator also emits the **Rust payload bindings** under `crates/eql-bindings/src/v3/.rs` (structs + `DomainType` impls) and the `inventory.rs` `all()` list, from the same `CATALOG` — committed with a `// @generated` header (the bindings must exist on a clean clone because `ts-rs`/`schemars` derive the committed TypeScript/JSON Schema off them; the SQL surface is now committed too, so both generated targets are handled consistently — committed in place, drift-gated by regenerate-and-`git diff`). The hand-written `DomainType` trait, the shared newtypes (`SchemaVersion`/`Identifier`/`Ciphertext`/`Hmac256`/`OreBlock256`/`BloomFilter`), the `PhantomData` plumbing, and the architectural module doc (including the non-derivable float-NaN and bool storage-only caveats) stay hand-written in `crates/eql-bindings/src/v3/{mod,domain_type,terms}.rs`. Generated structs carry a catalog-derived struct doc — a summary line (`` `eql_v3.` — . ``) plus a detail line listing the supported operators and required payload keys, all derived from data the catalog already holds (the capability label, `Term::operators_for_terms`, and `ENVELOPE_KEYS` ++ `Term::term_json_keys` — see `struct_doc_lines` in `crates/eql-codegen/src/bindings.rs`). The required-key list makes structural distinctions visible — e.g. `text_ord` lists `` `v` `i` `c` `hm` `ob` `` (dual-term) versus an integer `integer_ord`'s `` `v` `i` `c` `ob` ``. There are **no per-field docs**: per-field/term semantics live on the shared term newtypes (`terms.rs`, flowing into the TS term files and JSON Schema `$defs`), and non-derivable per-family caveats (float-NaN, bool storage-only) in `mod.rs`. Free-form prose belongs at the **struct level** (a future optional catalog `doc` field emitted as extra `#[doc]` lines), never as per-field docs. JSON Schemas are emitted by **schemars 1.x** as JSON Schema 2020-12. `mise run types:generate` regenerates the Rust bindings (via `eql-codegen bindings`) then the TS/JSON; `mise run types:check` is the committed-reference drift gate — it regenerates and `git diff`s all three (`crates/eql-bindings/src/v3` + `bindings/` + `schema/`), the same regenerate-and-diff pattern `codegen:parity` now uses for the committed SQL surface. Both gates run in CI; `mise run install-hooks` wires a pre-commit hook that runs both locally whenever a commit touches the catalog, the generator, or a committed generated surface. The `json` family's **SteVec** structs (`SteVecDocument`/`SteVecEntry`/`SteVecQuery`, plus the shared `SteVecTerm`/`SteVecQueryEntry`/`OreCllw`/`Selector` newtypes) are hand-written for the same reason as their SQL — in `crates/eql-bindings/src/v3/jsonb.rs`, symmetric with `src/v3/json/` — their field layout (`#[serde(flatten)]`, an `Option` array marker, per-struct serde strictness) isn't derivable from the catalog the way a flat scalar struct is. The family's scalar storage struct **is** generated (a flat `{v,i,c}` struct, `Jsonb`), via `render_scalar_only_bindings(&JSONB)` into `crates/eql-bindings/src/v3/jsonb_storage.rs`; the hand-written `jsonb.rs` re-exports it (`pub use crate::v3::jsonb_storage::Jsonb;`) so `super::jsonb::Jsonb` resolves for the generated inventory/payload. Only inventory membership and ordering are catalog-driven: `inventory.rs::all()` iterates the full `CATALOG` (not `scalar_families()`), branching on `Shape` to include the three SteVec structs plus the generated `Jsonb` alongside the other scalar structs. **Adding a new encrypted-domain type: follow `docs/reference/adding-a-scalar-encrypted-domain-type.md`.** The mechanics are fixed for ordered scalar domains; the catalog row only declares the name, kind, bare domain names, and terms. New term behavior belongs in the `Term` enum's `impl` methods in `crates/eql-domains/src` with tests, not in free-form catalog data. diff --git a/crates/eql-bindings/bindings/v3/Json.ts b/crates/eql-bindings/bindings/v3/Json.ts new file mode 100644 index 000000000..7690666ff --- /dev/null +++ b/crates/eql-bindings/bindings/v3/Json.ts @@ -0,0 +1,11 @@ +// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually. +import type { Ciphertext } from "./Ciphertext"; +import type { Identifier } from "./Identifier"; +import type { SchemaVersion } from "./SchemaVersion"; + +/** + * `public.eql_v3_json` — storage-only domain. + * + * Operators: none. Required keys: `v` `i` `c`. + */ +export type Json = { v: SchemaVersion, i: Identifier, c: Ciphertext, }; diff --git a/crates/eql-bindings/bindings/v3/Selector.ts b/crates/eql-bindings/bindings/v3/Selector.ts index deb18a4da..c380e1e75 100644 --- a/crates/eql-bindings/bindings/v3/Selector.ts +++ b/crates/eql-bindings/bindings/v3/Selector.ts @@ -2,6 +2,6 @@ /** * A SteVec selector — the `s` wire key. Addresses a JSON path leaf within an - * encrypted document (`public.eql_v3_json`); present on every entry and query element. + * encrypted document (`public.eql_v3_json_search`); present on every entry and query element. */ export type Selector = string; diff --git a/crates/eql-bindings/bindings/v3/SteVecDocument.ts b/crates/eql-bindings/bindings/v3/SteVecDocument.ts index 59b432b26..8c3643641 100644 --- a/crates/eql-bindings/bindings/v3/SteVecDocument.ts +++ b/crates/eql-bindings/bindings/v3/SteVecDocument.ts @@ -5,7 +5,7 @@ import type { SteVecEntry } from "./SteVecEntry"; import type { SteVecForm } from "./SteVecForm"; /** - * `public.eql_v3_json` — a SteVec encrypted-JSONB document (`{v, k, i, sv:[entry]}`, + * `public.eql_v3_json_search` — a SteVec encrypted-JSON document (`{v, k, i, sv:[entry]}`, * no root ciphertext). Strict. `k` is the `"sv"` form discriminator (see * [`SteVecForm`]) — carried on the real wire, so the strict struct models it. */ diff --git a/crates/eql-bindings/bindings/v3/SteVecEntry.ts b/crates/eql-bindings/bindings/v3/SteVecEntry.ts index 78f3cd9da..ba2429b80 100644 --- a/crates/eql-bindings/bindings/v3/SteVecEntry.ts +++ b/crates/eql-bindings/bindings/v3/SteVecEntry.ts @@ -5,7 +5,7 @@ import type { OpeCllw } from "./OpeCllw"; import type { Selector } from "./Selector"; /** - * `public.eql_v3_jsonb_entry` — one sv element (returned by `->`). Carries a selector + * `public.eql_v3_json_entry` — one sv element (returned by `->`). Carries a selector * `s`, ciphertext `c`, optional array-membership marker `a`, and exactly one of * `hm` XOR `op`. LAX (flatten precludes `deny_unknown_fields`): tolerates the * root `i`/`v` merged in by `->`. XOR of the term is enforced by the SQL CHECK. diff --git a/crates/eql-bindings/bindings/v3/SteVecQuery.ts b/crates/eql-bindings/bindings/v3/SteVecQuery.ts index eb1cab954..6ea0225d7 100644 --- a/crates/eql-bindings/bindings/v3/SteVecQuery.ts +++ b/crates/eql-bindings/bindings/v3/SteVecQuery.ts @@ -2,6 +2,6 @@ import type { SteVecQueryEntry } from "./SteVecQueryEntry"; /** - * `eql_v3.query_jsonb` — a containment needle (`{sv:[query-entry]}`). Strict. + * `eql_v3.query_json` — a containment needle (`{sv:[query-entry]}`). Strict. */ export type SteVecQuery = { sv: Array, }; diff --git a/crates/eql-bindings/schema/v3/eql_v3_json.json b/crates/eql-bindings/schema/v3/eql_v3_json.json index 048152251..5a206f9d9 100644 --- a/crates/eql-bindings/schema/v3/eql_v3_json.json +++ b/crates/eql-bindings/schema/v3/eql_v3_json.json @@ -4,10 +4,6 @@ "description": "mp_base85 source ciphertext — the `c` envelope key.\n\nRequired by every v3 domain CHECK; present on every payload.", "type": "string" }, - "Hmac256": { - "description": "HMAC-SHA-256 equality term — the `hm` wire key. Backs the `_eq` domains\n(`=`, `<>`). SQL-side constructor: `eql_v3_internal.hmac_256`.", - "type": "string" - }, "Identifier": { "additionalProperties": false, "description": "Table + column identifier — wire shape `{\"t\": \"...\", \"c\": \"...\"}`.\n\nShared by every payload.", @@ -27,98 +23,32 @@ ], "type": "object" }, - "OpeCllw": { - "description": "CLLW-OPE order term — the `op` wire key. Backs the scalar `_ord` (the\ndefault ordering domain), `_ord_ope`, and `text_search` domains, their\n`query_` operands (`=` `<>` `<` `<=` `>` `>=`), and the ordered entries\nof a SteVec document (exactly one of `hm` (equality) XOR `op` (ordering)\nper entry — enforced by the SQL domain CHECK): a hex-encoded CLLW OPE\nciphertext, sortable via native bytea comparison after hex-decode —\nunlike `ob` (block-ORE) it needs no custom comparator. Extracted by\n`eql_v3.ord_term` (scalar domains and the `public.jsonb_entry` overload\nalike); SQL-side constructor: `eql_v3_internal.ope_cllw`.", - "type": "string" - }, "SchemaVersion": { "const": 3, "description": "The envelope version field (`v`) — always exactly `3` on the wire.", "type": "integer" - }, - "Selector": { - "description": "A SteVec selector — the `s` wire key. Addresses a JSON path leaf within an\nencrypted document (`public.eql_v3_json`); present on every entry and query element.", - "type": "string" - }, - "SteVecEntry": { - "anyOf": [ - { - "properties": { - "hm": { - "$ref": "#/$defs/Hmac256" - } - }, - "required": [ - "hm" - ], - "type": "object" - }, - { - "properties": { - "op": { - "$ref": "#/$defs/OpeCllw" - } - }, - "required": [ - "op" - ], - "type": "object" - } - ], - "description": "`public.eql_v3_jsonb_entry` — one sv element (returned by `->`). Carries a selector\n`s`, ciphertext `c`, optional array-membership marker `a`, and exactly one of\n`hm` XOR `op`. LAX (flatten precludes `deny_unknown_fields`): tolerates the\nroot `i`/`v` merged in by `->`. XOR of the term is enforced by the SQL CHECK.", - "properties": { - "a": { - "type": [ - "boolean", - "null" - ] - }, - "c": { - "$ref": "#/$defs/Ciphertext" - }, - "s": { - "$ref": "#/$defs/Selector" - } - }, - "required": [ - "s", - "c" - ], - "type": "object" - }, - "SteVecForm": { - "const": "sv", - "description": "The `k` envelope form discriminator — always `\"sv\"` for a SteVec document.", - "type": "string" } }, "$id": "https://schemas.cipherstash.com/eql/v3/eql_v3_json.json", "$schema": "https://json-schema.org/draft/2020-12/schema", "additionalProperties": false, - "description": "`public.eql_v3_json` — a SteVec encrypted-JSONB document (`{v, k, i, sv:[entry]}`,\nno root ciphertext). Strict. `k` is the `\"sv\"` form discriminator (see\n[`SteVecForm`]) — carried on the real wire, so the strict struct models it.", + "description": "`public.eql_v3_json` — storage-only domain.\n\nOperators: none. Required keys: `v` `i` `c`.", "properties": { + "c": { + "$ref": "#/$defs/Ciphertext" + }, "i": { "$ref": "#/$defs/Identifier" }, - "k": { - "$ref": "#/$defs/SteVecForm" - }, - "sv": { - "items": { - "$ref": "#/$defs/SteVecEntry" - }, - "type": "array" - }, "v": { "$ref": "#/$defs/SchemaVersion" } }, "required": [ "v", - "k", "i", - "sv" + "c" ], - "title": "SteVecDocument", + "title": "Json", "type": "object" } \ No newline at end of file diff --git a/crates/eql-bindings/schema/v3/eql_v3_jsonb_entry.json b/crates/eql-bindings/schema/v3/eql_v3_json_entry.json similarity index 80% rename from crates/eql-bindings/schema/v3/eql_v3_jsonb_entry.json rename to crates/eql-bindings/schema/v3/eql_v3_json_entry.json index 5a593c34c..ca28a3cbe 100644 --- a/crates/eql-bindings/schema/v3/eql_v3_jsonb_entry.json +++ b/crates/eql-bindings/schema/v3/eql_v3_json_entry.json @@ -13,11 +13,11 @@ "type": "string" }, "Selector": { - "description": "A SteVec selector — the `s` wire key. Addresses a JSON path leaf within an\nencrypted document (`public.eql_v3_json`); present on every entry and query element.", + "description": "A SteVec selector — the `s` wire key. Addresses a JSON path leaf within an\nencrypted document (`public.eql_v3_json_search`); present on every entry and query element.", "type": "string" } }, - "$id": "https://schemas.cipherstash.com/eql/v3/eql_v3_jsonb_entry.json", + "$id": "https://schemas.cipherstash.com/eql/v3/eql_v3_json_entry.json", "$schema": "https://json-schema.org/draft/2020-12/schema", "anyOf": [ { @@ -43,7 +43,7 @@ "type": "object" } ], - "description": "`public.eql_v3_jsonb_entry` — one sv element (returned by `->`). Carries a selector\n`s`, ciphertext `c`, optional array-membership marker `a`, and exactly one of\n`hm` XOR `op`. LAX (flatten precludes `deny_unknown_fields`): tolerates the\nroot `i`/`v` merged in by `->`. XOR of the term is enforced by the SQL CHECK.", + "description": "`public.eql_v3_json_entry` — one sv element (returned by `->`). Carries a selector\n`s`, ciphertext `c`, optional array-membership marker `a`, and exactly one of\n`hm` XOR `op`. LAX (flatten precludes `deny_unknown_fields`): tolerates the\nroot `i`/`v` merged in by `->`. XOR of the term is enforced by the SQL CHECK.", "properties": { "a": { "type": [ diff --git a/crates/eql-bindings/schema/v3/eql_v3_json_search.json b/crates/eql-bindings/schema/v3/eql_v3_json_search.json new file mode 100644 index 000000000..9aafe9a01 --- /dev/null +++ b/crates/eql-bindings/schema/v3/eql_v3_json_search.json @@ -0,0 +1,124 @@ +{ + "$defs": { + "Ciphertext": { + "description": "mp_base85 source ciphertext — the `c` envelope key.\n\nRequired by every v3 domain CHECK; present on every payload.", + "type": "string" + }, + "Hmac256": { + "description": "HMAC-SHA-256 equality term — the `hm` wire key. Backs the `_eq` domains\n(`=`, `<>`). SQL-side constructor: `eql_v3_internal.hmac_256`.", + "type": "string" + }, + "Identifier": { + "additionalProperties": false, + "description": "Table + column identifier — wire shape `{\"t\": \"...\", \"c\": \"...\"}`.\n\nShared by every payload.", + "properties": { + "c": { + "description": "Column name.", + "type": "string" + }, + "t": { + "description": "Table name.", + "type": "string" + } + }, + "required": [ + "t", + "c" + ], + "type": "object" + }, + "OpeCllw": { + "description": "CLLW-OPE order term — the `op` wire key. Backs the scalar `_ord` (the\ndefault ordering domain), `_ord_ope`, and `text_search` domains, their\n`query_` operands (`=` `<>` `<` `<=` `>` `>=`), and the ordered entries\nof a SteVec document (exactly one of `hm` (equality) XOR `op` (ordering)\nper entry — enforced by the SQL domain CHECK): a hex-encoded CLLW OPE\nciphertext, sortable via native bytea comparison after hex-decode —\nunlike `ob` (block-ORE) it needs no custom comparator. Extracted by\n`eql_v3.ord_term` (scalar domains and the `public.jsonb_entry` overload\nalike); SQL-side constructor: `eql_v3_internal.ope_cllw`.", + "type": "string" + }, + "SchemaVersion": { + "const": 3, + "description": "The envelope version field (`v`) — always exactly `3` on the wire.", + "type": "integer" + }, + "Selector": { + "description": "A SteVec selector — the `s` wire key. Addresses a JSON path leaf within an\nencrypted document (`public.eql_v3_json_search`); present on every entry and query element.", + "type": "string" + }, + "SteVecEntry": { + "anyOf": [ + { + "properties": { + "hm": { + "$ref": "#/$defs/Hmac256" + } + }, + "required": [ + "hm" + ], + "type": "object" + }, + { + "properties": { + "op": { + "$ref": "#/$defs/OpeCllw" + } + }, + "required": [ + "op" + ], + "type": "object" + } + ], + "description": "`public.eql_v3_json_entry` — one sv element (returned by `->`). Carries a selector\n`s`, ciphertext `c`, optional array-membership marker `a`, and exactly one of\n`hm` XOR `op`. LAX (flatten precludes `deny_unknown_fields`): tolerates the\nroot `i`/`v` merged in by `->`. XOR of the term is enforced by the SQL CHECK.", + "properties": { + "a": { + "type": [ + "boolean", + "null" + ] + }, + "c": { + "$ref": "#/$defs/Ciphertext" + }, + "s": { + "$ref": "#/$defs/Selector" + } + }, + "required": [ + "s", + "c" + ], + "type": "object" + }, + "SteVecForm": { + "const": "sv", + "description": "The `k` envelope form discriminator — always `\"sv\"` for a SteVec document.", + "type": "string" + } + }, + "$id": "https://schemas.cipherstash.com/eql/v3/eql_v3_json_search.json", + "$schema": "https://json-schema.org/draft/2020-12/schema", + "additionalProperties": false, + "description": "`public.eql_v3_json_search` — a SteVec encrypted-JSON document (`{v, k, i, sv:[entry]}`,\nno root ciphertext). Strict. `k` is the `\"sv\"` form discriminator (see\n[`SteVecForm`]) — carried on the real wire, so the strict struct models it.", + "properties": { + "i": { + "$ref": "#/$defs/Identifier" + }, + "k": { + "$ref": "#/$defs/SteVecForm" + }, + "sv": { + "items": { + "$ref": "#/$defs/SteVecEntry" + }, + "type": "array" + }, + "v": { + "$ref": "#/$defs/SchemaVersion" + } + }, + "required": [ + "v", + "k", + "i", + "sv" + ], + "title": "SteVecDocument", + "type": "object" +} \ No newline at end of file diff --git a/crates/eql-bindings/schema/v3/query_jsonb.json b/crates/eql-bindings/schema/v3/query_json.json similarity index 90% rename from crates/eql-bindings/schema/v3/query_jsonb.json rename to crates/eql-bindings/schema/v3/query_json.json index ee72912b6..32e468b90 100644 --- a/crates/eql-bindings/schema/v3/query_jsonb.json +++ b/crates/eql-bindings/schema/v3/query_json.json @@ -9,7 +9,7 @@ "type": "string" }, "Selector": { - "description": "A SteVec selector — the `s` wire key. Addresses a JSON path leaf within an\nencrypted document (`public.eql_v3_json`); present on every entry and query element.", + "description": "A SteVec selector — the `s` wire key. Addresses a JSON path leaf within an\nencrypted document (`public.eql_v3_json_search`); present on every entry and query element.", "type": "string" }, "SteVecQueryEntry": { @@ -49,10 +49,10 @@ "type": "object" } }, - "$id": "https://schemas.cipherstash.com/eql/v3/query_jsonb.json", + "$id": "https://schemas.cipherstash.com/eql/v3/query_json.json", "$schema": "https://json-schema.org/draft/2020-12/schema", "additionalProperties": false, - "description": "`eql_v3.query_jsonb` — a containment needle (`{sv:[query-entry]}`). Strict.", + "description": "`eql_v3.query_json` — a containment needle (`{sv:[query-entry]}`). Strict.", "properties": { "sv": { "items": { diff --git a/crates/eql-bindings/src/from_v2/error.rs b/crates/eql-bindings/src/from_v2/error.rs index 8e49dd242..44bfbc85c 100644 --- a/crates/eql-bindings/src/from_v2/error.rs +++ b/crates/eql-bindings/src/from_v2/error.rs @@ -24,7 +24,7 @@ pub enum FromV2Error { }, /// [`TargetDomain::parse`](super::TargetDomain::parse) did not find the /// name in the catalog-generated inventory (or it names a SteVec shape — - /// `jsonb_entry` / `query_jsonb` — that is not a conversion target). + /// `jsonb_entry` / `query_json` — that is not a conversion target). UnknownDomain { /// The name that failed to resolve. name: String, @@ -35,7 +35,7 @@ pub enum FromV2Error { /// is [`FromV2Error::AmbiguousTerm`]) with `entry` locating the offender. MissingTerm { /// The (unqualified) target domain name, e.g. `text_eq`, or the - /// SteVec shape (`json` / `query_jsonb`) for per-entry terms. + /// SteVec shape (`json` / `query_json`) for per-entry terms. domain: String, /// The missing wire key (`hm`/`ob`/`bf`/`op`, or `hm|op` for entries). key: String, diff --git a/crates/eql-bindings/src/from_v2/mod.rs b/crates/eql-bindings/src/from_v2/mod.rs index 2f5407c68..0bed64bfc 100644 --- a/crates/eql-bindings/src/from_v2/mod.rs +++ b/crates/eql-bindings/src/from_v2/mod.rs @@ -41,7 +41,7 @@ //! **SteVec** (v2 `k: "sv"` → [`TargetDomain::Json`]): keeps the root `k` //! (the v3 document models the `"sv"` form discriminator — required on the //! wire), sets `v: 3`, keeps `i`; per entry keeps `s`, `c`, the optional -//! array-membership marker `a` (the v3 [`crate::v3::jsonb::SteVecEntry`] +//! array-membership marker `a` (the v3 [`crate::v3::json::SteVecEntry`] //! retains it), and exactly one of `hm` XOR `op` //! ([`FromV2Error::AmbiguousTerm`] / [`FromV2Error::MissingTerm`] on //! both/neither). Like scalar `op`, the sv-level `op` term predates the @@ -53,7 +53,7 @@ //! OPE cannot be determined from the payload alone. Fail closed; //! re-encryption is the only conversion. v3 sv entries carry no per-entry //! `v`/`i`/`k` — the envelope lives only at the root `{v, k, i, sv}`, -//! exactly the [`crate::v3::jsonb::SteVecDocument`] shape. +//! exactly the [`crate::v3::json::SteVecDocument`] shape. //! //! Every converted payload is validated by a final strict parse through the //! target's binding struct (`deny_unknown_fields` + [`crate::SchemaVersion`]) @@ -68,7 +68,7 @@ //! ## Query payloads //! //! [`from_v2_query`] covers both query shapes. The jsonb containment needle -//! (`{sv: [{s, hm|op}]}` → [`crate::v3::jsonb::SteVecQuery`]) normalizes +//! (`{sv: [{s, hm|op}]}` → [`crate::v3::json::SteVecQuery`]) normalizes //! entries down to `s` + one term exactly as the SQL cast //! `eql_v3.to_ste_vec_query` does (stray `a` markers and `c` ciphertexts are //! stripped). A term-bearing scalar target hoists the target's required terms @@ -138,7 +138,7 @@ pub fn from_v2_typed(v2: &Value, target: TargetDomain) -> Result Result { /// Convert an EQL v2.3 QUERY payload into the v3 query operand for `target`. /// /// [`TargetDomain::Json`]: the v2 containment needle (`{sv: [{s, hm|op}]}`, the -/// v2.3 `SteVecQueryPayload`) converts to the [`crate::v3::jsonb::SteVecQuery`] +/// v2.3 `SteVecQueryPayload`) converts to the [`crate::v3::json::SteVecQuery`] /// shape — entries normalized to `s` + exactly one term (mirroring /// `eql_v3.to_ste_vec_query`; stray `a`/`c` keys are stripped, so a stored /// document payload can also be normalized into a needle), `i` dropped. @@ -217,12 +217,12 @@ pub fn from_v2_query_typed(v2: &Value, target: TargetDomain) -> Result`, or `query_jsonb` for the hand-written SteVec needle — +/// twin `query_`, or `query_json` for the hand-written SteVec needle — /// both on the query-operand PREFIX convention (CIP-3442). (Replaces the old /// single `QUERY_DOMAIN` constant now that scalar query shapes exist.) fn query_domain_name(target: TargetDomain) -> String { match target { - TargetDomain::Json => "query_jsonb".to_string(), + TargetDomain::Json => "query_json".to_string(), // The query twin joins `query_` to the BARE domain name: the stored // domain's `eql_v3_` version prefix (CIP-3472) applies to public-schema // column types only — query operands live in the already-versioned @@ -358,7 +358,7 @@ fn validate_as(domain: &str, value: &Value) -> Result<(), FromV2Error> { .find(|d| d.domain() == domain) .unwrap_or_else(|| { // `domain` always came from the same inventory via - // `TargetDomain::parse` (or is the literal "eql_v3_json"/"query_jsonb"). + // `TargetDomain::parse` (or is the literal "eql_v3_json_search"/"query_json"). unreachable!("domain {domain} resolved by parse must be in the inventory") }); entry.parse_value(value).map_err(FromV2Error::Invalid) @@ -426,7 +426,7 @@ fn convert_ste_vec(obj: &Map) -> Result { let mut out = Map::new(); out.insert("v".into(), json!(crate::EQL_SCHEMA_VERSION)); // The root `k: "sv"` form discriminator is carried through: the v3 - // document models it ([`crate::v3::jsonb::SteVecDocument`]'s `k`, + // document models it ([`crate::v3::json::SteVecDocument`]'s `k`, // required on the wire). `from_v2` already dispatched on `k == "sv"`, so // emitting the literal is exact. out.insert("k".into(), json!("sv")); @@ -466,7 +466,7 @@ fn convert_ste_vec_query(v2: &Value) -> Result { Some(kind) => { return Err(FromV2Error::KindMismatch { kind: kind.into(), - target: "eql_v3_json".into(), + target: "eql_v3_json_search".into(), }) } } @@ -505,8 +505,8 @@ impl EntryShape { /// context. fn domain(self) -> &'static str { match self { - Self::Document => "eql_v3_json", - Self::Query => "query_jsonb", + Self::Document => "eql_v3_json_search", + Self::Query => "query_json", } } } diff --git a/crates/eql-bindings/src/from_v2/target.rs b/crates/eql-bindings/src/from_v2/target.rs index af2358026..88423ded9 100644 --- a/crates/eql-bindings/src/from_v2/target.rs +++ b/crates/eql-bindings/src/from_v2/target.rs @@ -16,7 +16,7 @@ pub enum TargetDomain { /// A flat scalar domain (`integer`, `text_eq`, `integer_ord_ope`, …): the v2 /// payload must be the `k: "ct"` form. Scalar(ScalarTarget), - /// The SteVec document domain `public.eql_v3_json`: the v2 payload must be the + /// The SteVec document domain `public.eql_v3_json_search`: the v2 payload must be the /// `k: "sv"` form. Json, } @@ -45,12 +45,12 @@ impl ScalarTarget { impl TargetDomain { /// Resolve an unqualified v3 domain name (`"eql_v3_integer_ord_ope"`, - /// `"text_search"`, `"float8"`, `"eql_v3_json"`, …) against the inventory. + /// `"text_search"`, `"float8"`, `"eql_v3_json_search"`, …) against the inventory. /// /// Shape-aware: scalar domains resolve to [`TargetDomain::Scalar`] with /// their catalog term keys; the SteVec document domain `json` resolves to /// [`TargetDomain::Json`]; the remaining SteVec shapes (`jsonb_entry`, - /// `query_jsonb`) are inventory members but not conversion targets, so + /// `query_json`) are inventory members but not conversion targets, so /// they — like any unknown name — return /// [`FromV2Error::UnknownDomain`]. pub fn parse(name: &str) -> Result { @@ -61,7 +61,7 @@ impl TargetDomain { domain: d.domain(), term_keys, })), - None if name == "eql_v3_json" => Ok(Self::Json), + None if name == "eql_v3_json_search" => Ok(Self::Json), None => Err(FromV2Error::UnknownDomain { name: name.into() }), }, None => Err(FromV2Error::UnknownDomain { name: name.into() }), @@ -69,11 +69,11 @@ impl TargetDomain { } /// The target's name for error messages: the scalar domain name, or - /// `"eql_v3_json"`. + /// `"eql_v3_json_search"`. pub(super) fn describe(&self) -> &'static str { match self { Self::Scalar(t) => t.domain(), - Self::Json => "eql_v3_json", + Self::Json => "eql_v3_json_search", } } } diff --git a/crates/eql-bindings/src/v3/domain_type.rs b/crates/eql-bindings/src/v3/domain_type.rs index 7df0575aa..799f30bdd 100644 --- a/crates/eql-bindings/src/v3/domain_type.rs +++ b/crates/eql-bindings/src/v3/domain_type.rs @@ -16,11 +16,11 @@ use serde::Deserialize; pub const SQL_SCHEMA: &str = "public"; /// The version prefix every public-schema column domain's typname carries -/// (`eql_v3_integer_eq`, `eql_v3_json`, … — CIP-3472). Mirrors +/// (`eql_v3_integer_eq`, `eql_v3_json_search`, … — CIP-3472). Mirrors /// `eql_domains::PUBLIC_TYPNAME_PREFIX` (a dev-dependency here, so the /// literal is repeated); parity with the catalog is pinned exhaustively by /// `tests/catalog_parity.rs`. Query-operand domains (`query_`, -/// `query_jsonb`) are NOT prefixed — the `eql_v3` schema they live in +/// `query_json`) are NOT prefixed — the `eql_v3` schema they live in /// already versions them. pub const PUBLIC_TYPNAME_PREFIX: &str = "eql_v3_"; diff --git a/crates/eql-bindings/src/v3/inventory.rs b/crates/eql-bindings/src/v3/inventory.rs index b22b2f14b..1c8db5805 100644 --- a/crates/eql-bindings/src/v3/inventory.rs +++ b/crates/eql-bindings/src/v3/inventory.rs @@ -57,9 +57,10 @@ pub fn all() -> Vec> { Box::new(PhantomData::), Box::new(PhantomData::), Box::new(PhantomData::), - Box::new(PhantomData::), - Box::new(PhantomData::), - Box::new(PhantomData::), + Box::new(PhantomData::), + Box::new(PhantomData::), + Box::new(PhantomData::), + Box::new(PhantomData::), ] } /// Every v3 QUERY-operand twin (`eql_v3.query_`, the enveloped diff --git a/crates/eql-bindings/src/v3/jsonb.rs b/crates/eql-bindings/src/v3/json.rs similarity index 84% rename from crates/eql-bindings/src/v3/jsonb.rs rename to crates/eql-bindings/src/v3/json.rs index 4a1f2d919..c3946c74b 100644 --- a/crates/eql-bindings/src/v3/jsonb.rs +++ b/crates/eql-bindings/src/v3/json.rs @@ -1,9 +1,9 @@ -//! The `jsonb` (SteVec) encrypted-JSONB payload types — HAND-WRITTEN. +//! The `json` (SteVec) encrypted-JSON payload types — HAND-WRITTEN. //! //! Unlike the scalar families, the SteVec struct bodies (fields, `#[serde(flatten)]`, //! the `Option` array marker, per-struct serde strictness) are not derivable //! from `eql-domains::CATALOG`, so they live here by hand — symmetric with the -//! hand-written SQL under `src/v3/jsonb/`. The generated `inventory.rs` still lists +//! hand-written SQL under `src/v3/json/`. The generated `inventory.rs` still lists //! these three domains (in CATALOG order) via its `Shape` branch. See the SteVec //! caveat in `mod.rs` for why the entry/query structs are necessarily lax. @@ -15,6 +15,14 @@ use crate::v3::terms::{Ciphertext, Hmac256, OpeCllw, Selector}; use crate::v3::DomainType; use crate::{Identifier, SchemaVersion}; +/// The bare ciphertext-only storage domain `public.eql_v3_json` — a flat +/// `{v,i,c}` scalar struct, GENERATED (unlike the SteVec structs in this +/// module) into `json_storage.rs` by the catalog materializer. Re-exported here +/// so the generated `inventory.rs` / `payload.rs`, which reference every json +/// domain's struct through `super::json::`, resolve `Json` without a +/// shape-aware module path in the renderer. +pub use crate::v3::json_storage::Json; + /// The `k` envelope key — the EQL payload **form discriminator**, always the /// literal `"sv"` for an encrypted-JSONB document. /// @@ -71,7 +79,7 @@ impl JsonSchema for SteVecForm { } } -/// `public.eql_v3_json` — a SteVec encrypted-JSONB document (`{v, k, i, sv:[entry]}`, +/// `public.eql_v3_json_search` — a SteVec encrypted-JSON document (`{v, k, i, sv:[entry]}`, /// no root ciphertext). Strict. `k` is the `"sv"` form discriminator (see /// [`SteVecForm`]) — carried on the real wire, so the strict struct models it. #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)] @@ -84,7 +92,7 @@ pub struct SteVecDocument { pub sv: Vec, } -/// `public.eql_v3_jsonb_entry` — one sv element (returned by `->`). Carries a selector +/// `public.eql_v3_json_entry` — one sv element (returned by `->`). Carries a selector /// `s`, ciphertext `c`, optional array-membership marker `a`, and exactly one of /// `hm` XOR `op`. LAX (flatten precludes `deny_unknown_fields`): tolerates the /// root `i`/`v` merged in by `->`. XOR of the term is enforced by the SQL CHECK. @@ -105,7 +113,7 @@ pub struct SteVecEntry { pub term: SteVecTerm, } -/// `eql_v3.query_jsonb` — a containment needle (`{sv:[query-entry]}`). Strict. +/// `eql_v3.query_json` — a containment needle (`{sv:[query-entry]}`). Strict. #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)] #[ts(export, export_to = "v3/")] #[serde(deny_unknown_fields)] @@ -155,6 +163,6 @@ macro_rules! ste_vec_domain_type { }; } -ste_vec_domain_type!(SteVecDocument, "public.eql_v3_json"); -ste_vec_domain_type!(SteVecEntry, "public.eql_v3_jsonb_entry"); -ste_vec_domain_type!(SteVecQuery, "eql_v3.query_jsonb"); +ste_vec_domain_type!(SteVecDocument, "public.eql_v3_json_search"); +ste_vec_domain_type!(SteVecEntry, "public.eql_v3_json_entry"); +ste_vec_domain_type!(SteVecQuery, "eql_v3.query_json"); diff --git a/crates/eql-bindings/src/v3/json_storage.rs b/crates/eql-bindings/src/v3/json_storage.rs new file mode 100644 index 000000000..4a969edb5 --- /dev/null +++ b/crates/eql-bindings/src/v3/json_storage.rs @@ -0,0 +1,39 @@ +// @generated by eql-codegen from the eql-domains catalog — do not edit +//! The generated scalar (storage) domain(s) of the `json` encrypted-domain family — generated from the eql-domains catalog. The family's SteVec domains are hand-written in `json.rs`. +use crate::v3::terms::Ciphertext; +use crate::v3::DomainType; +use crate::{Identifier, SchemaVersion}; +use schemars::{schema_for, JsonSchema, Schema}; +use serde::{Deserialize, Serialize}; +use ts_rs::TS; +/// `public.eql_v3_json` — storage-only domain. +/// +/// Operators: none. Required keys: `v` `i` `c`. +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)] +#[ts(export, export_to = "v3/")] +#[serde(deny_unknown_fields)] +pub struct Json { + pub v: SchemaVersion, + pub i: Identifier, + pub c: Ciphertext, +} +impl DomainType for Json { + fn sql_domain_static() -> &'static str { + "public.eql_v3_json" + } + fn sql_domain(&self) -> &'static str { + Self::sql_domain_static() + } + fn term_json_keys_static() -> Option<&'static [&'static str]> { + Some(&[]) + } + fn term_json_keys(&self) -> Option<&'static [&'static str]> { + Self::term_json_keys_static() + } + fn parse_value(&self, value: &serde_json::Value) -> Result<(), serde_json::Error> { + Json::deserialize(value).map(|_| ()) + } + fn schema(&self) -> Schema { + schema_for!(Json) + } +} diff --git a/crates/eql-bindings/src/v3/mod.rs b/crates/eql-bindings/src/v3/mod.rs index 25e8e5e33..80d38cacd 100644 --- a/crates/eql-bindings/src/v3/mod.rs +++ b/crates/eql-bindings/src/v3/mod.rs @@ -45,7 +45,7 @@ //! domain's set fails to deserialize rather than being silently stripped on the //! next serialize (a pass-through consumer must not lose data it didn't know //! about), and the `v` field is [`crate::SchemaVersion`], which rejects any -//! version other than `3`. The SteVec `jsonb` family below is structurally +//! version other than `3`. The SteVec `json` family below is structurally //! different: its document/root shape has no root `c`, its entries flatten a //! term enum, and only the flatten-free structs can be strict. //! @@ -60,7 +60,7 @@ //! typed domain is the discriminator. If a producer emitted `k:"ct"` on a scalar //! payload, these strict structs would reject it; no test currently parses real //! scalar ciphertext into the bindings, so that path is unverified.) The one -//! place `k` is modelled is the SteVec **document** — see the `jsonb` note below. +//! place `k` is modelled is the SteVec **document** — see the `json` note below. //! //! ## Why there is no discriminated enum //! @@ -81,10 +81,10 @@ //! follows the same Serialize-only rule for QUERY payloads — see its module //! doc for why it is hand-written rather than generated. //! -//! The SteVec `jsonb` family is the ONE principled exception: a single encrypted +//! The SteVec `json` family is the ONE principled exception: a single encrypted //! document legitimately mixes `hm` leaves (bool / root) and `op` leaves //! (string / number) in one `sv` array, so `SteVecEntry` must hold either term. -//! There the untagged [`jsonb::SteVecTerm`] (`{hm} | {op}`) is inherent to the +//! There the untagged [`json::SteVecTerm`] (`{hm} | {op}`) is inherent to the //! wire, not a sniffing workaround — the "per-domain typing is possible" //! reasoning above simply does not apply to a heterogeneous `sv` array. //! @@ -109,7 +109,7 @@ //! searchable index (even HMAC equality) would trivially leak the plaintext //! distribution. The payload is `{v,i,c}` only and every operator is blocked. //! -//! **`jsonb` (SteVec) is the one place `Option` and lax serde appear.** +//! **`json` (SteVec) is the one place `Option` and lax serde appear.** //! `SteVecEntry.a` is `Option` — the sv-array-membership marker, absent //! for non-array leaves — the sole `Option` in this module. `SteVecEntry` and //! `SteVecQueryEntry` both carry a `#[serde(flatten)] SteVecTerm`, and serde @@ -127,7 +127,7 @@ //! *requires* `k` (`required: [v,k,i,sv]`, `const "sv"`) and cipherstash-client //! emits it on every real SteVec document. Because `SteVecDocument` is strict //! (`deny_unknown_fields`), it MUST model `k` or it rejects the real wire — so it -//! carries a [`jsonb::SteVecForm`] field pinned to `"sv"`, exactly as +//! carries a [`json::SteVecForm`] field pinned to `"sv"`, exactly as //! `SchemaVersion` pins `v`. `SteVecQuery` needs no `k`: it is a locally-built //! `{sv:[…]}` containment needle (`eql_v3.to_ste_vec_query`), not a stored //! envelope. `eql_v3` itself never reads `k`; it is passthrough form metadata @@ -140,7 +140,12 @@ pub mod domain_type; pub mod double; pub mod integer; pub mod inventory; -pub mod jsonb; +pub mod json; +/// Generated bindings for the `json` family's bare scalar storage domain +/// (`public.eql_v3_json`, the `Json` struct). Kept separate from the +/// hand-written SteVec `json` module; `json` re-exports `Json` from here so +/// `super::json::Json` resolves for the generated inventory/payload. +pub mod json_storage; pub mod numeric; pub mod payload; pub mod query_payload; diff --git a/crates/eql-bindings/src/v3/payload.rs b/crates/eql-bindings/src/v3/payload.rs index 61a65313b..3c3ebed4b 100644 --- a/crates/eql-bindings/src/v3/payload.rs +++ b/crates/eql-bindings/src/v3/payload.rs @@ -115,8 +115,10 @@ pub enum DomainPayload { DoubleOrd(super::double::DoubleOrd), /// The `public.eql_v3_double_ord_ope` payload. DoubleOrdOpe(super::double::DoubleOrdOpe), + /// The `public.eql_v3_json_search` payload. + SteVecDocument(super::json::SteVecDocument), /// The `public.eql_v3_json` payload. - SteVecDocument(super::jsonb::SteVecDocument), + Json(super::json::Json), } impl DomainPayload { /// Strictly parse `value` as `domain`'s payload, KEEPING the @@ -257,9 +259,10 @@ impl DomainPayload { "eql_v3_double_ord_ope" => { Some(super::double::DoubleOrdOpe::deserialize(value).map(Self::DoubleOrdOpe)) } - "eql_v3_json" => { - Some(super::jsonb::SteVecDocument::deserialize(value).map(Self::SteVecDocument)) + "eql_v3_json_search" => { + Some(super::json::SteVecDocument::deserialize(value).map(Self::SteVecDocument)) } + "eql_v3_json" => Some(super::json::Json::deserialize(value).map(Self::Json)), _ => None, } } @@ -316,6 +319,7 @@ impl DomainPayload { Self::DoubleOrd(payload) => payload, Self::DoubleOrdOpe(payload) => payload, Self::SteVecDocument(payload) => payload, + Self::Json(payload) => payload, } } /// Fully-qualified SQL domain name, e.g. `"public.eql_v3_integer_eq"`. diff --git a/crates/eql-bindings/src/v3/query_payload.rs b/crates/eql-bindings/src/v3/query_payload.rs index b7e4d1f8a..685a693e8 100644 --- a/crates/eql-bindings/src/v3/query_payload.rs +++ b/crates/eql-bindings/src/v3/query_payload.rs @@ -5,7 +5,7 @@ use serde::{Deserialize, Serialize}; /// Every v3 QUERY-operand shape in one type: one variant per term-bearing /// scalar query twin (`eql_v3.query_`, the enveloped term-only /// operand — `{v, i, }`, no `c`) plus the SteVec containment -/// needle (`eql_v3.query_jsonb`). Generated from the catalog, so it +/// needle (`eql_v3.query_json`). Generated from the catalog, so it /// cannot drift when the catalog grows. /// /// Serialization is exactly the inner struct's (`#[serde(untagged)]` @@ -95,8 +95,8 @@ pub enum QueryPayload { DoubleOrdQuery(super::double::DoubleOrdQuery), /// The `eql_v3.query_double_ord_ope` query operand. DoubleOrdOpeQuery(super::double::DoubleOrdOpeQuery), - /// The `eql_v3.query_jsonb` query operand. - SteVec(super::jsonb::SteVecQuery), + /// The `eql_v3.query_json` query operand. + SteVec(super::json::SteVecQuery), } impl QueryPayload { /// Strictly parse `value` as `domain`'s query payload, KEEPING the @@ -236,7 +236,7 @@ impl QueryPayload { "query_double_ord_ope" => Some( super::double::DoubleOrdOpeQuery::deserialize(value).map(Self::DoubleOrdOpeQuery), ), - "query_jsonb" => Some(super::jsonb::SteVecQuery::deserialize(value).map(Self::SteVec)), + "query_json" => Some(super::json::SteVecQuery::deserialize(value).map(Self::SteVec)), _ => None, } } diff --git a/crates/eql-bindings/src/v3/terms.rs b/crates/eql-bindings/src/v3/terms.rs index dc9e74572..8a39902d2 100644 --- a/crates/eql-bindings/src/v3/terms.rs +++ b/crates/eql-bindings/src/v3/terms.rs @@ -29,7 +29,7 @@ pub struct Ciphertext(pub String); pub struct Hmac256(pub String); /// A SteVec selector — the `s` wire key. Addresses a JSON path leaf within an -/// encrypted document (`public.eql_v3_json`); present on every entry and query element. +/// encrypted document (`public.eql_v3_json_search`); present on every entry and query element. #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize, TS, JsonSchema)] #[ts(export, export_to = "v3/")] pub struct Selector(pub String); diff --git a/crates/eql-bindings/tests/catalog_parity.rs b/crates/eql-bindings/tests/catalog_parity.rs index 972c399ed..f475fe4ab 100644 --- a/crates/eql-bindings/tests/catalog_parity.rs +++ b/crates/eql-bindings/tests/catalog_parity.rs @@ -72,7 +72,7 @@ fn schema_required_keys_match_catalog_terms() { #[test] fn inventory_exactly_covers_catalog_in_order() { // `domain_name` is correct for every shape (including the jsonb family's - // one documented exception, the `public.eql_v3_json` document domain — see + // one documented exception, the `public.eql_v3_json_search` document domain — see // `Domain::full_name`), so no per-shape branch is needed here. let expected: Vec = CATALOG .iter() @@ -156,9 +156,9 @@ fn parse_value_validates_through_the_inventory() { "i": { "t": "users", "c": "profile" }, "sv": [ { "s": "sel", "c": "ct", "hm": "deadbeef" } ] }); - assert!(entry("eql_v3_json").parse_value(&doc).is_ok()); - assert!(entry("query_jsonb").parse_value(&doc).is_err()); - assert!(entry("query_jsonb") + assert!(entry("eql_v3_json_search").parse_value(&doc).is_ok()); + assert!(entry("query_json").parse_value(&doc).is_err()); + assert!(entry("query_json") .parse_value(&json!({ "sv": [ { "s": "sel", "hm": "deadbeef" } ] })) .is_ok()); } @@ -261,12 +261,12 @@ fn schemas_are_strict() { /// /// KEEP IN SYNC with the canonical `SteVecPayload` /// (`eql-payload-v2.3.schema.json`) and `is_valid_ste_vec_{document,entry,query}_payload`: -/// - `public.eql_v3_json` requires `v` `k` `i` `sv` (document; `k` = "sv" +/// - `public.eql_v3_json_search` requires `v` `k` `i` `sv` (document; `k` = "sv" /// form discriminator, required by the canonical SteVecPayload and carried on /// every real payload — the SQL CHECK is laxer and only mandates `v`/`i`/`sv`, /// but the binding models the real wire, which always carries `k`) -/// - `public.eql_v3_jsonb_entry` requires `s` `c` + exactly one of `hm` XOR `op` -/// - `eql_v3.query_jsonb` requires `sv`; each element `s` + `hm` XOR `op`, no `c` +/// - `public.eql_v3_json_entry` requires `s` `c` + exactly one of `hm` XOR `op` +/// - `eql_v3.query_json` requires `sv`; each element `s` + `hm` XOR `op`, no `c` #[test] fn jsonb_schema_required_keys_match_the_sql_check_contract() { let entries = v3::all(); @@ -291,22 +291,22 @@ fn jsonb_schema_required_keys_match_the_sql_check_contract() { // Document: {v, k, i, sv}. No root `c` (a document is not itself a // ciphertext); `k` is the "sv" form discriminator (SteVecForm-pinned). - let doc = schema_of("eql_v3_json"); + let doc = schema_of("eql_v3_json_search"); assert_eq!( - required(&doc, "/required", "eql_v3_json"), + required(&doc, "/required", "eql_v3_json_search"), set(&["v", "k", "i", "sv"]), - "public.eql_v3_json required keys must match the SteVec document wire contract" + "public.eql_v3_json_search required keys must match the SteVec document wire contract" ); // Entry: {s, c} + hm XOR op. The XOR is expressed as an untagged `anyOf` // over {hm} | {op} (serde/schemars cannot express exclusivity; the SQL CHECK // owns the XOR). Assert both the base required set and that BOTH term // alternatives are reachable. - let entry = schema_of("eql_v3_jsonb_entry"); + let entry = schema_of("eql_v3_json_entry"); assert_eq!( - required(&entry, "/required", "eql_v3_jsonb_entry"), + required(&entry, "/required", "eql_v3_json_entry"), set(&["s", "c"]), - "public.eql_v3_jsonb_entry base required keys must be s + c" + "public.eql_v3_json_entry base required keys must be s + c" ); let entry_alts = entry .pointer("/anyOf") @@ -322,30 +322,30 @@ fn jsonb_schema_required_keys_match_the_sql_check_contract() { entry_alt_required.len() == 2 && entry_alt_required.contains(&set(&["hm"])) && entry_alt_required.contains(&set(&["op"])), - "public.eql_v3_jsonb_entry anyOf must offer exactly the hm-only and op-only term \ + "public.eql_v3_json_entry anyOf must offer exactly the hm-only and op-only term \ alternatives (each arm a singleton), got {entry_alt_required:?}" ); // Query: {sv}. The element (SteVecQueryEntry) requires `s` + hm XOR op and // carries NO ciphertext `c` — the "queries never carry ciphertext" rule. - let query = schema_of("query_jsonb"); + let query = schema_of("query_json"); assert_eq!( - required(&query, "/required", "query_jsonb"), + required(&query, "/required", "query_json"), set(&["sv"]), - "eql_v3.query_jsonb required keys must be sv" + "eql_v3.query_json required keys must be sv" ); let elem_required = required( &query, "/$defs/SteVecQueryEntry/required", - "query_jsonb element", + "query_json element", ); assert!( elem_required.contains("s"), - "query_jsonb element must require a selector s, got {elem_required:?}" + "query_json element must require a selector s, got {elem_required:?}" ); assert!( !elem_required.contains("c"), - "query_jsonb element must NOT require a ciphertext c \ + "query_json element must NOT require a ciphertext c \ (is_valid_ste_vec_query_payload forbids it), got {elem_required:?}" ); // Same arm-wise check as jsonb_entry: the query element's hm XOR op union must @@ -353,16 +353,16 @@ fn jsonb_schema_required_keys_match_the_sql_check_contract() { let query_alts = query .pointer("/$defs/SteVecQueryEntry/anyOf") .and_then(|v| v.as_array()) - .expect("query_jsonb element schema must carry an anyOf term union"); + .expect("query_json element schema must carry an anyOf term union"); let query_alt_required: Vec> = query_alts .iter() - .map(|alt| required(alt, "/required", "query_jsonb element anyOf")) + .map(|alt| required(alt, "/required", "query_json element anyOf")) .collect(); assert!( query_alt_required.len() == 2 && query_alt_required.contains(&set(&["hm"])) && query_alt_required.contains(&set(&["op"])), - "eql_v3.query_jsonb element anyOf must offer exactly the hm-only and \ + "eql_v3.query_json element anyOf must offer exactly the hm-only and \ op-only term alternatives (each arm a singleton), got {query_alt_required:?}" ); } diff --git a/crates/eql-bindings/tests/domain_payload.rs b/crates/eql-bindings/tests/domain_payload.rs index 907d1662c..16bae1c40 100644 --- a/crates/eql-bindings/tests/domain_payload.rs +++ b/crates/eql-bindings/tests/domain_payload.rs @@ -150,8 +150,8 @@ fn typed_scalar_multi_term_yields_text_search_ore() { #[test] fn typed_ste_vec_document_yields_ste_vec_document() { let typed = assert_serialization_pin(&v2_sv(), TargetDomain::Json); - assert_eq!(typed.domain(), "eql_v3_json"); - assert_eq!(typed.sql_domain(), "public.eql_v3_json"); + assert_eq!(typed.domain(), "eql_v3_json_search"); + assert_eq!(typed.sql_domain(), "public.eql_v3_json_search"); match &typed { DomainPayload::SteVecDocument(doc) => { assert_eq!(doc.sv.len(), 2, "entry order/count preserved"); @@ -228,13 +228,13 @@ fn parse_constructs_every_stored_payload_domain() { for family in eql_domains::CATALOG { for domain in family.domains { let name = family.domain_name(domain); - let stored = domain.is_scalar() || name == "eql_v3_json"; - let value = if name == "eql_v3_json" { + let stored = domain.is_scalar() || name == "eql_v3_json_search"; + let value = if name == "eql_v3_json_search" { from_v2(&v2_sv(), TargetDomain::Json).unwrap() } else if stored { from_v2(&v2_ct_full(), target(&name)).unwrap() } else { - // jsonb_entry / query_jsonb: inventory members but not stored + // jsonb_entry / query_json: inventory members but not stored // payloads — no DomainPayload variant, parse returns None. assert!( DomainPayload::parse(&name, &json!({})).is_none(), @@ -258,8 +258,8 @@ fn parse_returns_none_for_unknown_domains() { "public.eql_v3_integer_eq", "", "jsonb", - "eql_v3_jsonb_entry", - "query_jsonb", + "eql_v3_json_entry", + "query_json", ] { assert!( DomainPayload::parse(name, &json!({})).is_none(), diff --git a/crates/eql-bindings/tests/from_v2.rs b/crates/eql-bindings/tests/from_v2.rs index 5fae375a2..7ffbf453d 100644 --- a/crates/eql-bindings/tests/from_v2.rs +++ b/crates/eql-bindings/tests/from_v2.rs @@ -79,7 +79,7 @@ fn parse_resolves_every_catalog_scalar_domain_and_json() { matches!(parsed, Ok(TargetDomain::Scalar(_))), "{name} must parse to Scalar, got {parsed:?}" ); - } else if name == "eql_v3_json" { + } else if name == "eql_v3_json_search" { assert_eq!(parsed.unwrap(), TargetDomain::Json); } else { assert!( @@ -410,7 +410,7 @@ fn ste_vec_entry_with_neither_term_is_missing() { let err = from_v2(&v2, TargetDomain::Json).unwrap_err(); match err { FromV2Error::MissingTerm { domain, key, entry } => { - assert_eq!(domain, "eql_v3_json"); + assert_eq!(domain, "eql_v3_json_search"); assert_eq!(key, "hm|op"); assert_eq!(entry, Some(1)); } @@ -457,12 +457,12 @@ fn ste_vec_query_entry_term_errors_match_document_rules() { from_v2_query(&both, TargetDomain::Json).unwrap_err(), FromV2Error::AmbiguousTerm { entry: 0 } )); - // The query path names ITS shape (query_jsonb, not json) and locates the + // The query path names ITS shape (query_json, not json) and locates the // entry. let neither = json!({ "sv": [ { "s": SELECTOR, "hm": HEX }, { "s": SELECTOR } ] }); match from_v2_query(&neither, TargetDomain::Json).unwrap_err() { FromV2Error::MissingTerm { domain, key, entry } => { - assert_eq!(domain, "query_jsonb"); + assert_eq!(domain, "query_json"); assert_eq!(key, "hm|op"); assert_eq!(entry, Some(1)); } diff --git a/crates/eql-bindings/tests/query_payload.rs b/crates/eql-bindings/tests/query_payload.rs index 3c1642879..697f17766 100644 --- a/crates/eql-bindings/tests/query_payload.rs +++ b/crates/eql-bindings/tests/query_payload.rs @@ -67,12 +67,12 @@ fn typed_needle_yields_the_ste_vec_variant() { ] }); let typed = assert_serialization_pin(&v2); - assert_eq!(typed.domain(), "query_jsonb"); - assert_eq!(typed.sql_domain(), "eql_v3.query_jsonb"); + assert_eq!(typed.domain(), "query_json"); + assert_eq!(typed.sql_domain(), "eql_v3.query_json"); match &typed { QueryPayload::SteVec(q) => { assert_eq!(q.sv.len(), 2, "entry order/count preserved"); - assert_eq!(q.sql_domain(), "eql_v3.query_jsonb"); + assert_eq!(q.sql_domain(), "eql_v3.query_json"); } other => panic!("a jsonb target must yield the SteVec needle, got {other:?}"), } @@ -190,7 +190,7 @@ fn typed_entry_term_errors_match_from_v2_query() { let neither = json!({ "sv": [ { "s": SELECTOR, "hm": HEX }, { "s": SELECTOR } ] }); match from_v2_query_typed(&neither, TargetDomain::Json).unwrap_err() { FromV2Error::MissingTerm { domain, key, entry } => { - assert_eq!(domain, "query_jsonb"); + assert_eq!(domain, "query_json"); assert_eq!(key, "hm|op"); assert_eq!(entry, Some(1)); } @@ -228,10 +228,10 @@ fn typed_rejects_the_same_envelopes_as_from_v2_query() { #[test] fn parse_constructs_the_needle_from_its_domain_name() { let needle = json!({ "sv": [ { "s": SELECTOR, "hm": HEX } ] }); - let parsed = QueryPayload::parse("query_jsonb", &needle) - .expect("query_jsonb must be a QueryPayload domain") + let parsed = QueryPayload::parse("query_json", &needle) + .expect("query_json must be a QueryPayload domain") .expect("strict parse must succeed"); - assert_eq!(parsed.domain(), "query_jsonb"); + assert_eq!(parsed.domain(), "query_json"); assert_eq!(serde_json::to_value(&parsed).unwrap(), needle); } @@ -241,7 +241,7 @@ fn parse_is_strict_exactly_like_the_binding_struct() { // fails, exactly as the untyped path's validate_as does. let stray = json!({ "sv": [ { "s": SELECTOR, "hm": HEX } ], "extra": 1 }); assert!( - QueryPayload::parse("query_jsonb", &stray).unwrap().is_err(), + QueryPayload::parse("query_json", &stray).unwrap().is_err(), "deny_unknown_fields must reject a stray root key" ); } @@ -251,10 +251,10 @@ fn parse_returns_none_for_non_query_domains() { // Stored-payload domains (DomainPayload territory), the entry shape, and // unknown names are not query payloads. for name in [ - "eql_v3_json", - "eql_v3_jsonb_entry", + "eql_v3_json_search", + "eql_v3_json_entry", "eql_v3_integer_eq", - "eql_v3.query_jsonb", + "eql_v3.query_json", "", ] { assert!( diff --git a/crates/eql-bindings/tests/v3_conformance.rs b/crates/eql-bindings/tests/v3_conformance.rs index fb30ef237..0afbdb626 100644 --- a/crates/eql-bindings/tests/v3_conformance.rs +++ b/crates/eql-bindings/tests/v3_conformance.rs @@ -404,7 +404,7 @@ fn timestamp_round_trips_and_enforces_term_capabilities() { #[test] fn stevec_document_round_trips_and_enforces_envelope() { - use eql_bindings::v3::jsonb::SteVecDocument; + use eql_bindings::v3::json::SteVecDocument; use eql_bindings::v3::DomainType; // The real cipherstash SteVec document envelope carries the `k` form // discriminator (`"sv"`), required by the canonical eql-payload-v2.3 @@ -422,7 +422,10 @@ fn stevec_document_round_trips_and_enforces_envelope() { }); let parsed: SteVecDocument = serde_json::from_value(wire.clone()).unwrap(); assert_eq!(serde_json::to_value(&parsed).unwrap(), wire); - assert_eq!(SteVecDocument::sql_domain_static(), "public.eql_v3_json"); + assert_eq!( + SteVecDocument::sql_domain_static(), + "public.eql_v3_json_search" + ); // Envelope negatives (parity with the scalar integer tests) — now including `k`. for missing in ["v", "k", "i", "sv"] { @@ -456,7 +459,7 @@ fn stevec_document_round_trips_and_enforces_envelope() { #[test] fn stevec_entry_untagged_term_and_neither_term_rejected() { - use eql_bindings::v3::jsonb::{SteVecEntry, SteVecTerm}; + use eql_bindings::v3::json::{SteVecEntry, SteVecTerm}; // hm arm. let hm: SteVecEntry = serde_json::from_value(json!({ "s": "sel", "c": "ct", "hm": "deadbeef" })).unwrap(); @@ -488,7 +491,7 @@ fn stevec_entry_both_terms_present_resolves_to_first_untagged_arm() { // rather than erroring. This pins that resolution so a reorder of the // `SteVecTerm` variants (which would silently flip the winner to `oc`) is a // test failure, and documents that client-side parsing does not enforce XOR. - use eql_bindings::v3::jsonb::{SteVecEntry, SteVecTerm}; + use eql_bindings::v3::json::{SteVecEntry, SteVecTerm}; let both: SteVecEntry = serde_json::from_value(json!({ "s": "sel", "c": "ct", "hm": "deadbeef", "oc": "cllw" })) .expect( @@ -503,12 +506,12 @@ fn stevec_entry_both_terms_present_resolves_to_first_untagged_arm() { #[test] fn stevec_query_round_trips() { - use eql_bindings::v3::jsonb::SteVecQuery; + use eql_bindings::v3::json::SteVecQuery; use eql_bindings::v3::DomainType; let wire = json!({ "sv": [ { "s": "sel", "hm": "deadbeef" } ] }); let parsed: SteVecQuery = serde_json::from_value(wire.clone()).unwrap(); assert_eq!(serde_json::to_value(&parsed).unwrap(), wire); - assert_eq!(SteVecQuery::sql_domain_static(), "eql_v3.query_jsonb"); + assert_eq!(SteVecQuery::sql_domain_static(), "eql_v3.query_json"); // Unknown top-level key rejected (SteVecQuery has no flatten field). assert!(serde_json::from_value::(json!({ "sv": [], "bogus": 1 })).is_err()); // NOTE: a query ELEMENT carrying `c` is NOT rejected here — SteVecQueryEntry @@ -519,7 +522,7 @@ fn stevec_query_round_trips() { #[test] fn stevec_document_and_query_schemas_are_strict() { - use eql_bindings::v3::jsonb::{SteVecDocument, SteVecForm, SteVecQuery}; + use eql_bindings::v3::json::{SteVecDocument, SteVecForm, SteVecQuery}; use eql_bindings::v3::DomainType; use eql_bindings::{Identifier, SchemaVersion}; let doc = SteVecDocument { @@ -551,8 +554,11 @@ fn stevec_document_and_query_schemas_are_strict() { let sq = serde_json::to_value(q.schema()).unwrap(); assert_eq!(sq.pointer("/additionalProperties"), Some(&json!(false))); // SteVecDocument/Query domain names. - assert_eq!(SteVecDocument::sql_domain_static(), "public.eql_v3_json"); - assert_eq!(SteVecQuery::sql_domain_static(), "eql_v3.query_jsonb"); + assert_eq!( + SteVecDocument::sql_domain_static(), + "public.eql_v3_json_search" + ); + assert_eq!(SteVecQuery::sql_domain_static(), "eql_v3.query_json"); } #[test] diff --git a/crates/eql-codegen/src/bindings.rs b/crates/eql-codegen/src/bindings.rs index d52841169..1a8ee339a 100644 --- a/crates/eql-codegen/src/bindings.rs +++ b/crates/eql-codegen/src/bindings.rs @@ -325,6 +325,67 @@ pub fn render_family_bindings(family: &DomainFamily) -> String { format_rs(file) } +/// Render a bindings module for the **scalar domains only** of a mixed family — +/// currently just `jsonb` (its bare `public.eql_v3_json` storage struct). A +/// filtered twin of [`render_family_bindings`]: the SteVec domains' structs stay +/// hand-written in `json.rs` (their fields/serde aren't catalog-derivable), so +/// this must skip them or it would emit clashing/incorrect struct bodies. The +/// output is written to `_storage.rs` (e.g. `json_storage.rs`), NOT +/// `.rs`, so it never clobbers the hand-written module — the hand-written +/// `json.rs` re-exports the generated struct (`pub use ...::Jsonb;`) so +/// `super::json::Jsonb` resolves for the inventory/payload renderers. +pub fn render_scalar_only_bindings(family: &DomainFamily) -> String { + let mut used: Vec<&'static str> = vec!["Ciphertext"]; + for d in family.domains.iter().filter(|d| d.is_scalar()) { + for term in Term::payload_terms(d.terms) { + let t = term.binding_newtype(); + if !used.contains(&t) { + used.push(t); + } + } + } + let used_idents: Vec<_> = used.iter().map(|t| format_ident!("{t}")).collect(); + + // Scalar storage structs only, then a query twin for each term-bearing scalar + // domain (a bare storage domain has empty terms, so no query operand). + let structs: TokenStream = family + .domains + .iter() + .filter(|d| d.is_scalar()) + .map(|d| render_struct(family, d)) + .chain( + family + .domains + .iter() + .filter(|d| d.is_scalar() && !d.terms.is_empty()) + .map(|d| render_query_struct(family, d)), + ) + .collect(); + + let mod_doc = format!( + " The generated scalar (storage) domain(s) of the `{}` encrypted-domain family — \ + generated from the eql-domains catalog. The family's SteVec domains are hand-written \ + in `{}.rs`.", + family.name, family.name + ); + + let file = quote! { + #![doc = #mod_doc] + + use schemars::{schema_for, JsonSchema, Schema}; + + use crate::v3::terms::{ #(#used_idents),* }; + use crate::v3::DomainType; + use crate::{Identifier, SchemaVersion}; + use serde::{Deserialize, Serialize}; + use ts_rs::TS; + + #structs + }; + + format_rs(file) +} + /// Render the generated `crates/eql-bindings/src/v3/inventory.rs`: just `all()` /// in CATALOG order, referencing the family structs through `super::`. The /// `pub mod` declarations, the trait re-export, the trait/newtypes, and the @@ -404,15 +465,16 @@ pub fn render_inventory_rs() -> String { } /// The stored-payload domains of the catalog, in CATALOG order: every flat -/// scalar domain plus the SteVec document (`public.eql_v3_json`). The SteVec -/// entry/query shapes are inventory members but not stored column payloads, -/// so they are excluded — exactly the set `eql_bindings::from_v2` accepts as -/// conversion targets ([`render_payload_rs`]'s `DomainPayload` variants). +/// scalar domain (including the bare `public.eql_v3_json` storage domain) plus +/// the SteVec document (`public.eql_v3_json_search`). The SteVec entry/query +/// shapes are inventory members but not stored column payloads, so they are +/// excluded — exactly the set `eql_bindings::from_v2` accepts as conversion +/// targets ([`render_payload_rs`]'s `DomainPayload` variants). fn stored_payload_domains() -> impl Iterator { CATALOG .iter() .flat_map(|f| f.domains.iter().map(move |d| (f, d))) - .filter(|(f, d)| d.is_scalar() || d.full_name(f.name) == "json") + .filter(|(f, d)| d.is_scalar() || d.full_name(f.name) == "json_search") } /// Render the generated `crates/eql-bindings/src/v3/payload.rs`: the @@ -527,7 +589,7 @@ pub fn render_payload_rs() -> String { /// The catalog's QUERY-operand domains, in a stable order: a query twin for /// every term-bearing scalar domain (`eql_v3.query_`), then the SteVec -/// containment needle (`eql_v3.query_jsonb`). Exactly the shapes the generated +/// containment needle (`eql_v3.query_json`). Exactly the shapes the generated /// `QueryPayload` spans and `from_v2_query` can target. Returned as /// `(module, variant ident, struct ident, unqualified query-domain name)`; the /// SteVec needle keeps the `SteVec` variant name the `from_v2` query path @@ -545,10 +607,10 @@ fn query_payload_domains() -> Vec<(String, String, String, String)> { }) .collect(); out.push(( - "jsonb".into(), + "json".into(), "SteVec".into(), "SteVecQuery".into(), - "query_jsonb".into(), + "query_json".into(), )); out } @@ -556,7 +618,7 @@ fn query_payload_domains() -> Vec<(String, String, String, String)> { /// Render the generated `crates/eql-bindings/src/v3/query_payload.rs`: the /// `QueryPayload` enum spanning every QUERY-operand domain — a variant per /// term-bearing scalar query twin (`eql_v3.query_`) plus the SteVec -/// containment needle (`eql_v3.query_jsonb`) — with its +/// containment needle (`eql_v3.query_json`) — with its /// construct-from-known-domain `parse` constructor. /// /// Generated for the same reason as [`render_payload_rs`]'s `DomainPayload`: @@ -602,7 +664,7 @@ pub fn render_query_payload_rs() -> String { /// Every v3 QUERY-operand shape in one type: one variant per term-bearing /// scalar query twin (`eql_v3.query_`, the enveloped term-only /// operand — `{v, i, }`, no `c`) plus the SteVec containment - /// needle (`eql_v3.query_jsonb`). Generated from the catalog, so it + /// needle (`eql_v3.query_json`). Generated from the catalog, so it /// cannot drift when the catalog grows. /// /// Serialization is exactly the inner struct's (`#[serde(untagged)]` @@ -621,7 +683,7 @@ pub fn render_query_payload_rs() -> String { /// Strictly parse `value` as `domain`'s query payload, KEEPING the /// parsed value — the query-side counterpart of /// [`super::DomainPayload::parse`]. `domain` is the unqualified name - /// (`"query_integer_eq"`, `"query_jsonb"`, …). `None` when `domain` + /// (`"query_integer_eq"`, `"query_json"`, …). `None` when `domain` /// is not a query-operand domain; `Some(Err)` when the strict parse /// fails (`deny_unknown_fields` rejects a stray `c`). pub fn parse( @@ -676,6 +738,16 @@ fn render_bindings(dir: &Path) -> Vec<(PathBuf, String)> { ) }) .collect(); + // Mixed families (jsonb) are excluded from `scalar_families()`, so their + // scalar storage domain(s) render into a separate `_storage.rs` + // module — the SteVec `.rs` stays hand-written. Guarded so a family + // with no scalar domain emits nothing. + if eql_domains::JSON.domains.iter().any(|d| d.is_scalar()) { + rendered.push(( + dir.join(format!("{}_storage.rs", eql_domains::JSON.name)), + render_scalar_only_bindings(&eql_domains::JSON), + )); + } rendered.push((dir.join("payload.rs"), render_payload_rs())); rendered.push((dir.join("query_payload.rs"), render_query_payload_rs())); rendered.push((dir.join("inventory.rs"), render_inventory_rs())); @@ -931,9 +1003,11 @@ mod tests { let tmp = crate::writer::test_support::tempdir(); let written = generate_bindings(tmp.path()).unwrap(); let dir = tmp.path().join("crates/eql-bindings/src/v3"); - assert_eq!(written.len(), eql_domains::scalar_families().count() + 3); + // scalar families + jsonb_storage + payload + query_payload + inventory. + assert_eq!(written.len(), eql_domains::scalar_families().count() + 4); assert!(dir.join("integer.rs").is_file()); assert!(dir.join("text.rs").is_file()); + assert!(dir.join("json_storage.rs").is_file()); assert!(dir.join("payload.rs").is_file()); assert!(dir.join("inventory.rs").is_file()); assert!( @@ -964,7 +1038,7 @@ mod tests { let rendered = render_bindings(&dir); - assert_eq!(rendered.len(), eql_domains::scalar_families().count() + 3); + assert_eq!(rendered.len(), eql_domains::scalar_families().count() + 4); assert_eq!( std::fs::read_to_string(&sentinel).unwrap(), "SENTINEL", @@ -998,19 +1072,21 @@ mod tests { assert!(out.starts_with(crate::consts::RUST_GENERATED_MARKER)); // One variant per catalog (family, domain) pair that is a stored - // payload: every scalar domain plus the SteVec document. The SteVec + // payload: every scalar domain (incl. the bare `eql_v3_json` storage + // domain) plus the SteVec document (`eql_v3_json_search`). The SteVec // entry/query shapes are inventory members but not stored payloads. let expected: Vec = CATALOG .iter() .flat_map(|f| { f.domains .iter() - .filter(|d| d.is_scalar() || d.full_name(f.name) == "json") + .filter(|d| d.is_scalar() || d.full_name(f.name) == "json_search") .map(|d| d.rust_struct_name(f.name)) }) .collect(); assert_eq!(variant_idents(&out, "DomainPayload"), expected); - assert!(out.contains("SteVecDocument(super::jsonb::SteVecDocument)")); + assert!(out.contains("SteVecDocument(super::json::SteVecDocument)")); + assert!(out.contains("Json(super::json::Json)")); assert!(!expected.contains(&"SteVecEntry".to_string())); assert!(!expected.contains(&"SteVecQuery".to_string())); @@ -1021,7 +1097,10 @@ mod tests { )); assert!(out.contains(r#""eql_v3_integer_eq" =>"#)); assert!(out.contains("IntegerEq::deserialize(value).map(Self::IntegerEq)")); + // The bare storage domain and the searchable document have distinct arms. assert!(out.contains(r#""eql_v3_json" =>"#)); + assert!(out.contains("Json::deserialize(value).map(Self::Json)")); + assert!(out.contains(r#""eql_v3_json_search" =>"#)); assert!(out.contains("SteVecDocument::deserialize(value).map(Self::SteVecDocument)")); assert!(out.contains("_ => None,")); assert!(out.contains("pub fn as_domain_type(&self) -> &dyn DomainType")); @@ -1057,7 +1136,7 @@ mod tests { // parse arms keyed on the unqualified query-domain names. assert!(out.contains(r#""query_integer_eq" =>"#)); assert!(out.contains("IntegerEqQuery::deserialize(value).map(Self::IntegerEqQuery)")); - assert!(out.contains(r#""query_jsonb" =>"#)); + assert!(out.contains(r#""query_json" =>"#)); assert!(out.contains("SteVecQuery::deserialize(value).map(Self::SteVec)")); assert!(out.contains("_ => None,")); @@ -1216,12 +1295,20 @@ mod tests { let tmp = crate::writer::test_support::tempdir(); let dir = tmp.path().join(V3_BINDINGS_DIR); let rendered = render_bindings(&dir); + // The hand-written SteVec module `json.rs` is never generated... + assert!( + !rendered.iter().any(|(p, _)| p.ends_with("json.rs")), + "json.rs is hand-written; the generator must not emit it" + ); + // ...but the json family's bare scalar storage domain IS generated into a + // separate `json_storage.rs` module. assert!( - !rendered.iter().any(|(p, _)| p.ends_with("jsonb.rs")), - "jsonb.rs is hand-written; the generator must not emit it" + rendered.iter().any(|(p, _)| p.ends_with("json_storage.rs")), + "the json family's scalar storage domain must generate json_storage.rs" ); - // One file per scalar family + payload + inventory. - assert_eq!(rendered.len(), eql_domains::scalar_families().count() + 3); + // One file per scalar family + jsonb_storage + payload + query_payload + + // inventory. + assert_eq!(rendered.len(), eql_domains::scalar_families().count() + 4); } #[test] diff --git a/crates/eql-codegen/src/dump.rs b/crates/eql-codegen/src/dump.rs index 02c4891a4..cbae79d4a 100644 --- a/crates/eql-codegen/src/dump.rs +++ b/crates/eql-codegen/src/dump.rs @@ -9,12 +9,12 @@ use eql_domains::Term; use serde::Serialize; /// The catalog surface: every scalar type and its domains, plus the non-scalar -/// SteVec (`jsonb`) family. +/// SteVec (`json`) family. #[derive(Serialize)] pub struct CatalogDump { pub types: Vec, - /// The `jsonb` (SteVec) family — `public.eql_v3_json` / `public.eql_v3_jsonb_entry` / - /// `eql_v3.query_jsonb`. Their SQL is hand-written under `src/v3/jsonb/`; the + /// The `json` (SteVec) family — `public.eql_v3_json_search` / `public.eql_v3_json_entry` / + /// `eql_v3.query_json`. Their SQL is hand-written under `src/v3/json/`; the /// catalog owns only their inventory (scalar-only consumers ignore this field). pub stevec: Vec, } @@ -62,21 +62,21 @@ pub struct TermInfo { pub ctor: &'static str, } -/// One `jsonb` (SteVec) domain: catalog inventory only — its SQL surface +/// One `json` (SteVec) domain: catalog inventory only — its SQL surface /// (CHECK, operators) is hand-written and not derivable from the catalog. #[derive(Serialize)] pub struct SteVecEntry { - /// The bare domain name: `json` / `jsonb_entry` / `query_jsonb`. + /// The bare domain name: `json_search` / `json_entry` / `query_json`. pub full_name: String, /// The installed pg_type typname: the version-prefixed name for the - /// public-schema column domains (`eql_v3_json` / `eql_v3_jsonb_entry` — - /// CIP-3472); the containment needle stays `query_jsonb` (it lives in the + /// public-schema column domains (`eql_v3_json_search` / `eql_v3_json_entry` — + /// CIP-3472); the containment needle stays `query_json` (it lives in the /// already-versioned `eql_v3` schema). pub typname: String, /// The catalog domain name: `json` / `entry` / `query`. pub name: &'static str, - /// Index terms for this SteVec domain. Non-empty only for `jsonb_entry` - /// (the sv element type); the `json` container and `query_jsonb` domains + /// Index terms for this SteVec domain. Non-empty only for `json_entry` + /// (the sv element type); the `json` container and `query_json` domains /// carry no term extractors — see `stevec_terms`. pub terms: Vec, } @@ -92,17 +92,17 @@ fn term_infos(terms: &[Term]) -> Vec { .collect() } -/// Index terms for one `jsonb` (SteVec) domain, hardcoded for now. +/// Index terms for one `json` (SteVec) domain, hardcoded for now. /// -/// The catalog does not model per-SteVec-entry terms — `JSONB_DOMAINS` declare +/// The catalog does not model per-SteVec-entry terms — `JSON_DOMAINS` declare /// `terms: &[]` and the `shape_and_terms_are_consistent` invariant fails CI if a /// non-`Scalar` domain ever gains one — so `term_infos(d.terms)` is provably /// empty here. Until the catalog carries them, source the real hand-written -/// extractors from `src/v3/jsonb/{functions,operators}.sql`. +/// extractors from `src/v3/json/{functions,operators}.sql`. /// -/// Terms live on `jsonb_entry` — the sv *element* type — ONLY: `eql_v3.eq_term` +/// Terms live on `json_entry` — the sv *element* type — ONLY: `eql_v3.eq_term` /// reads `coalesce(hm, op)` for `=`/`<>`, and `eql_v3.ord_term` reads `op` for -/// `<`/`<=`/`>`/`>=`. The `json` container and `query_jsonb` domains carry no +/// `<`/`<=`/`>`/`>=`. The `json_search` document and `query_json` domains carry no /// term extractors (their surface is containment `@>`/`<@` and path navigation), /// so they return no terms. Keyed on the catalog domain name (`json`/`entry`/ /// `query`). @@ -158,15 +158,19 @@ pub fn dump_catalog() -> CatalogDump { // The hand-written SteVec (jsonb) family — catalog inventory only. Kept out // of `types` so scalar-only consumers (the fixture-coverage task) are // unaffected; the docs manifest reads both `types` and `stevec`. - let stevec = eql_domains::JSONB + let stevec = eql_domains::JSON .domains .iter() + // The json family is mixed: skip its bare scalar storage domain + // (`public.eql_v3_json`) — it is not a SteVec entry (it is generated by + // the scalar materializer and dumped, if at all, via `types`). + .filter(|d| !d.is_scalar()) .map(|d| SteVecEntry { - full_name: d.full_name(eql_domains::JSONB.name), - typname: d.sql_typname(eql_domains::JSONB.name), + full_name: d.full_name(eql_domains::JSON.name), + typname: d.sql_typname(eql_domains::JSON.name), name: d.name, // Catalog terms are empty for SteVec; hardcode per-domain — only - // `jsonb_entry` carries extractors (see stevec_terms). + // `json_entry` carries extractors (see stevec_terms). terms: stevec_terms(d.name), }) .collect(); @@ -239,10 +243,10 @@ mod tests { } #[test] - fn stevec_jsonb_family_is_dumped() { + fn stevec_json_family_is_dumped() { let dump = dump_catalog(); let names: Vec<&str> = dump.stevec.iter().map(|e| e.full_name.as_str()).collect(); - assert_eq!(names, ["json", "jsonb_entry", "query_jsonb"]); + assert_eq!(names, ["json_search", "json_entry", "query_json"]); let by_name = |n: &str| { dump.stevec @@ -251,19 +255,19 @@ mod tests { .unwrap_or_else(|| panic!("{n} present")) }; - // Term extractors live on `jsonb_entry` (the sv element type) ONLY: + // Term extractors live on `json_entry` (the sv element type) ONLY: // `eq_term` (hm/op equality) + `ord_term` (op ordering). - let entry_extractors: Vec<&str> = by_name("jsonb_entry") + let entry_extractors: Vec<&str> = by_name("json_entry") .terms .iter() .map(|t| t.extractor) .collect(); assert_eq!(entry_extractors, ["eq_term", "ord_term"]); - // The `json` container and `query_jsonb` domains carry no term + // The `json_search` document and `query_json` needle carry no term // extractors — their surface is containment (@>, <@) and path nav. - assert!(by_name("json").terms.is_empty()); - assert!(by_name("query_jsonb").terms.is_empty()); + assert!(by_name("json_search").terms.is_empty()); + assert!(by_name("query_json").terms.is_empty()); } /// Pins the hand-re-derived `suffix` wire field — the one channel with no @@ -305,20 +309,22 @@ mod tests { } #[test] - fn dump_catalog_excludes_non_scalar_jsonb() { + fn dump_catalog_excludes_non_scalar_json() { // `dump_catalog` (and, via the same `scalar_families()` filter, the CLI // `list-types` / `dump-catalog` output the scalar-matrix tooling consumes) - // must NOT surface the SteVec `jsonb` family: it has no `scalars::jsonb::*` - // matrix and no generated SQL surface, even though two of its three - // domain names (`public.eql_v3_jsonb_entry` / `eql_v3.query_jsonb`) now follow - // the family+suffix string convention — the payload shape is still not - // flat. This pins the exclusion directly at the codegen surface rather - // than relying only on the transitive `scalar_families()` guard in - // `eql-domains`. + // must NOT surface the mixed `json` family in `types`: its SteVec domains + // have no `scalars::json::*` matrix, even though its domain names + // (`public.eql_v3_json_entry` / `eql_v3.query_json`) follow the + // family+suffix string convention — the SteVec payload shape is still not + // flat, and the family is non-scalar. (Its bare storage domain IS + // generated, but storage-only types carry no operator matrix, so `json` + // stays out of `types`.) This pins the exclusion directly at the codegen + // surface rather than relying only on the transitive `scalar_families()` + // guard in `eql-domains`. let dump = dump_catalog(); assert!( - !dump.types.iter().any(|t| t.token == "jsonb"), - "dump_catalog must exclude the non-scalar jsonb family, got tokens: {:?}", + !dump.types.iter().any(|t| t.token == "json"), + "dump_catalog must exclude the non-scalar json family, got tokens: {:?}", dump.types.iter().map(|t| t.token).collect::>() ); // Sanity: the scalar families are still present (the filter isn't empty). diff --git a/crates/eql-codegen/src/generate.rs b/crates/eql-codegen/src/generate.rs index 6ab23b5ed..5093b7301 100644 --- a/crates/eql-codegen/src/generate.rs +++ b/crates/eql-codegen/src/generate.rs @@ -46,9 +46,13 @@ pub fn render_types_file(spec: &DomainFamily) -> String { use crate::context::{domain_block, environment, TypesContext}; let ctx = TypesContext { family_name: spec.name.to_string(), + // Only scalar domains are generated. For a fully-scalar family this is + // every domain (unchanged); for a mixed family (jsonb) it renders the + // bare scalar storage domain and skips the hand-written SteVec domains. domains: spec .domains .iter() + .filter(|d| d.is_scalar()) .map(|d| domain_block(spec.name, d)) .collect(), }; @@ -469,7 +473,11 @@ pub fn render_type(spec: &DomainFamily, out_dir: &Path) -> Vec<(PathBuf, String) render_query_types_file(spec), )); } - for d in spec.domains { + // Generate only scalar domains: identical to iterating every domain for a + // fully-scalar family; for a mixed family (jsonb) it emits the bare scalar + // storage surface and skips the hand-written SteVec domains under + // `src/v3/json/`. + for d in spec.domains.iter().filter(|d| d.is_scalar()) { let name = d.full_name(family_name); rendered.push(( out_dir.join(format!("{name}_functions.sql")), @@ -530,7 +538,10 @@ pub fn generate_type(spec: &DomainFamily, out_dir: &Path) -> Result pub fn generate_all(out_root: &Path) -> Result { let scalars_root = out_root.join(V3_SCALARS_DIR); let mut all_written: Vec = Vec::new(); - for spec in eql_domains::scalar_families() { + // Every family with at least one scalar domain: fully-scalar families are + // unchanged; a mixed family (jsonb) contributes only its scalar storage + // domain (the per-domain renderers filter `is_scalar()`). + for spec in eql_domains::families_with_scalar_domains() { let family_name = spec.name; let out_dir = scalars_root.join(family_name); let written = generate_type(spec, &out_dir)?; @@ -596,7 +607,9 @@ pub fn generate_all(out_root: &Path) -> Result { } } - let names: Vec<&str> = eql_domains::scalar_families().map(|s| s.name).collect(); + let names: Vec<&str> = eql_domains::families_with_scalar_domains() + .map(|s| s.name) + .collect(); println!("codegen: ok ({} types: {})", names.len(), names.join(", ")); Ok(0) } @@ -1135,6 +1148,44 @@ mod tests { ); } + #[test] + fn json_family_generates_only_its_scalar_storage_surface() { + // The mixed json family renders exactly the bare scalar storage domain + // (`public.eql_v3_json`): a types file + a functions file + an operators + // file, all named for the bare family name. No query twin, no aggregates + // (storage-only), and NONE of the hand-written SteVec domains + // (`search`/`entry`/`query`) may leak a generated file. + let s = spec("json"); + let rendered = render_type(s, std::path::Path::new("out")); + let names: Vec = rendered + .iter() + .map(|(p, _)| p.file_name().unwrap().to_string_lossy().into_owned()) + .collect(); + assert_eq!( + names, + vec!["json_types.sql", "json_functions.sql", "json_operators.sql"], + "json must emit exactly the bare scalar storage surface — the exact \ + file list also proves no SteVec domain (search/entry/query) leaked a \ + generated file" + ); + let by = |suffix: &str| { + &rendered + .iter() + .find(|(p, _)| p.file_name().unwrap().to_string_lossy().ends_with(suffix)) + .unwrap() + .1 + }; + assert!(by("json_types.sql").contains("CREATE DOMAIN public.eql_v3_json AS jsonb")); + assert_eq!( + by("json_functions.sql").matches("CREATE FUNCTION").count(), + 44 + ); + assert_eq!( + by("json_operators.sql").matches("CREATE OPERATOR").count(), + 44 + ); + } + // --- Coarsened footgun invariant guards (whole-file scans) --- #[test] diff --git a/crates/eql-codegen/tests/cli.rs b/crates/eql-codegen/tests/cli.rs index 2bfba964b..3a87548d2 100644 --- a/crates/eql-codegen/tests/cli.rs +++ b/crates/eql-codegen/tests/cli.rs @@ -33,8 +33,9 @@ fn tempdir() -> TempDir { /// `bindings` exits 0 and reports the written-file count. Run against a throwaway /// `EQL_CODEGEN_OUT_ROOT` tree so the smoke test proves the subcommand honours /// the output-root override (test isolation) and never touches the committed -/// `crates/eql-bindings/src/v3/*.rs`. The count is one file per catalog family -/// plus `payload.rs`, `query_payload.rs`, and `inventory.rs`. +/// `crates/eql-bindings/src/v3/*.rs`. The count is one file per scalar family +/// plus the jsonb family's generated `jsonb_storage.rs`, `payload.rs`, +/// `query_payload.rs`, and `inventory.rs`. #[test] fn bindings_subcommand_succeeds_and_reports_count() { let out_root = tempdir(); @@ -49,7 +50,7 @@ fn bindings_subcommand_succeeds_and_reports_count() { String::from_utf8_lossy(&out.stderr) ); let stdout = String::from_utf8_lossy(&out.stdout); - let expected = eql_domains::scalar_families().count() + 3; + let expected = eql_domains::scalar_families().count() + 4; assert!( stdout.contains(&format!("bindings: ok ({expected} files)")), "expected 'bindings: ok ({expected} files)' in stdout, got:\n{stdout}" diff --git a/crates/eql-codegen/tests/parity.rs b/crates/eql-codegen/tests/parity.rs index a44770896..e3fb90a04 100644 --- a/crates/eql-codegen/tests/parity.rs +++ b/crates/eql-codegen/tests/parity.rs @@ -63,14 +63,17 @@ fn committed_scalar_tokens(root: &Path) -> BTreeSet { fn committed_scalar_dirs_match_catalog_tokens() { let root = repo_root(); let dirs = committed_scalar_tokens(&root); - let catalog: BTreeSet = eql_domains::scalar_families() + // `families_with_scalar_domains()`, not `scalar_families()`: the mixed `json` + // family is non-scalar (it carries SteVec domains) but its bare scalar storage + // domain IS generated into `src/v3/scalars/json/`, so its token must appear. + let catalog: BTreeSet = eql_domains::families_with_scalar_domains() .map(|s| s.name.to_string()) .collect(); assert_eq!( dirs, catalog, - "committed src/v3/scalars// dirs must equal the catalog token set: a new \ - catalog type needs its regenerated SQL committed (run `mise run build` and commit \ - src/v3/scalars), and a stale dir with no catalog row must be removed" + "committed src/v3/scalars// dirs must equal the scalar-bearing catalog token \ + set: a new catalog type needs its regenerated SQL committed (run `mise run build` and \ + commit src/v3/scalars), and a stale dir with no catalog row must be removed" ); } diff --git a/crates/eql-domains/src/fixtures/mod.rs b/crates/eql-domains/src/fixtures/mod.rs index b847e0f26..df95bc5d3 100644 --- a/crates/eql-domains/src/fixtures/mod.rs +++ b/crates/eql-domains/src/fixtures/mod.rs @@ -17,7 +17,7 @@ pub use fixture::Fixture; pub use kind::{BoundedIntKind, ScalarKind}; pub use record::{ TypeFixtures, BIGINT_FIXTURES, BOOLEAN_FIXTURES, DATE_FIXTURES, DOUBLE_FIXTURES, FIXTURES, - INTEGER_FIXTURES, JSONB_FIXTURES, NUMERIC_FIXTURES, REAL_FIXTURES, SMALLINT_FIXTURES, + INTEGER_FIXTURES, JSON_FIXTURES, NUMERIC_FIXTURES, REAL_FIXTURES, SMALLINT_FIXTURES, TEXT_FIXTURES, TIMESTAMP_FIXTURES, }; pub use values::{BIGINT_VALUES, INTEGER_VALUES, SMALLINT_VALUES, TEXT_VALUES}; diff --git a/crates/eql-domains/src/fixtures/record.rs b/crates/eql-domains/src/fixtures/record.rs index 335b77f86..c817e465f 100644 --- a/crates/eql-domains/src/fixtures/record.rs +++ b/crates/eql-domains/src/fixtures/record.rs @@ -128,12 +128,12 @@ pub const DOUBLE_FIXTURES: TypeFixtures = TypeFixtures { "0", "0.001", "1", "1.5", "1000000", "1e300", "inf"), }; -/// jsonb fixtures — PLAINTEXT JSON document strings (NOT ciphertext). Mirrors +/// json fixtures — PLAINTEXT JSON document strings (NOT ciphertext). Mirrors /// the `v3_ste_vec` document shape (`hello`/`number`/`nested`), distinct by /// value. The ENCRYPTED SteVec fixture the binding conformance test uses is /// generated separately by `tests/sqlx/src/fixtures/v3_ste_vec.rs` (FixtureSpec). -pub const JSONB_FIXTURES: TypeFixtures = TypeFixtures { - family: &crate::JSONB, +pub const JSON_FIXTURES: TypeFixtures = TypeFixtures { + family: &crate::JSON, kind: ScalarKind::Jsonb, values: fixtures!(jsonb; "{\"hello\":\"world-1\",\"number\":1,\"nested\":{\"deep\":\"constant\"}}", @@ -155,7 +155,7 @@ pub const FIXTURES: &[TypeFixtures] = &[ BOOLEAN_FIXTURES, REAL_FIXTURES, DOUBLE_FIXTURES, - JSONB_FIXTURES, + JSON_FIXTURES, ]; /// Compile-time `&str` equality, usable in `const` context. `str::eq` / @@ -221,7 +221,7 @@ const fn expected_kind(name: &str) -> ScalarKind { ScalarKind::F32 } else if str_eq(name, "double") { ScalarKind::F64 - } else if str_eq(name, "jsonb") { + } else if str_eq(name, "json") { ScalarKind::Jsonb } else { panic!("unmapped scalar token in expected_kind — name its kind here") diff --git a/crates/eql-domains/src/lib.rs b/crates/eql-domains/src/lib.rs index e87106dde..11189a40d 100644 --- a/crates/eql-domains/src/lib.rs +++ b/crates/eql-domains/src/lib.rs @@ -29,7 +29,7 @@ mod term; pub use fixtures::{ BoundedIntKind, Fixture, ScalarKind, TypeFixtures, BIGINT_FIXTURES, BIGINT_VALUES, BOOLEAN_FIXTURES, DATE_FIXTURES, DOUBLE_FIXTURES, FIXTURES, INTEGER_FIXTURES, INTEGER_VALUES, - JSONB_FIXTURES, NUMERIC_FIXTURES, REAL_FIXTURES, SMALLINT_FIXTURES, SMALLINT_VALUES, + JSON_FIXTURES, NUMERIC_FIXTURES, REAL_FIXTURES, SMALLINT_FIXTURES, SMALLINT_VALUES, TEXT_FIXTURES, TEXT_VALUES, TIMESTAMP_FIXTURES, }; @@ -149,13 +149,15 @@ impl Role { pub enum Shape { /// Flat `{v, i, c, +terms}` — every existing scalar family (default). Scalar, - /// A `jsonb` family payload: `public.eql_v3_json` (`{v, i, sv: [entry]}`), - /// `public.eql_v3_jsonb_entry` (`{s, c, a?, #[flatten] SteVecTerm}`), or - /// `public.query_jsonb` (`{sv: [query-entry]}`). The three differ in - /// payload body but share the non-flat-scalar shape, so a single variant - /// covers them; `Domain.name` (`"json"`/`"entry"`/`"query"`) already - /// disambiguates which one a given domain is (see `Domain::full_name` / - /// `Domain::rust_struct_name`). + /// A `json` family SteVec payload: `public.eql_v3_json_search` + /// (`{v, i, sv: [entry]}`), `public.eql_v3_json_entry` + /// (`{s, c, a?, #[flatten] SteVecTerm}`), or `eql_v3.query_json` + /// (`{sv: [query-entry]}`). The three differ in payload body but share the + /// non-flat-scalar shape, so a single variant covers them; `Domain.name` + /// (`"search"`/`"entry"`/`"query"`) already disambiguates which one a given + /// domain is (see `Domain::full_name` / `Domain::rust_struct_name`). The + /// family's fourth domain, the bare storage domain `public.eql_v3_json`, is + /// `Shape::Scalar`, not SteVec. SteVec, } @@ -444,27 +446,39 @@ pub const DOUBLE: DomainFamily = DomainFamily { domains: ORDERED_INT_DOMAINS, }; -/// The SteVec (encrypted-JSONB) domains of the `jsonb` family. Every one has -/// empty `terms` — but these domains ARE searchable: each carries its index -/// terms *structurally*, inside the payload (`hm` for hash-equality, `op` for -/// CLLW-OPE ordering, one per `sv` leaf), not as a flat family-level `Term`. -/// Empty `terms` records "no flat-scalar term surface," never "no index -/// capability"; the capability is described by the `Shape` and enforced by the -/// hand-written SQL CHECKs under `src/v3/jsonb/`. The coupling is pinned by -/// `tests::shape_and_terms_are_consistent`. The SQL -/// surface is hand-written under `src/v3/jsonb/` (the SQL generator SKIPS these), -/// and the Rust payload structs are hand-written in -/// `crates/eql-bindings/src/v3/jsonb.rs` (their fields/serde are not derivable -/// from the catalog); the catalog drives only their inventory membership + order. -const JSONB_DOMAINS: &[Domain] = &[ +/// The domains of the `json` family — a **mixed** family: three SteVec +/// (encrypted-JSON) domains plus one bare scalar storage domain. +/// +/// The three SteVec domains (`search`/`entry`/`query`) all have empty `terms` +/// but ARE searchable: each carries its index terms *structurally*, inside the +/// payload (`hm` for hash-equality, `op` for CLLW-OPE ordering, one per `sv` +/// leaf), not as a flat family-level `Term`. Empty `terms` records "no +/// flat-scalar term surface," never "no index capability"; the capability is +/// described by the `Shape` and enforced by the hand-written SQL CHECKs under +/// `src/v3/json/`. Their SQL surface is hand-written under `src/v3/json/` and +/// their Rust payload structs are hand-written in +/// `crates/eql-bindings/src/v3/json.rs` (fields/serde not catalog-derivable); +/// the catalog drives only their inventory membership + order. The SQL/bindings +/// generators SKIP these SteVec domains (they iterate scalar domains only). +/// +/// The fourth, `Shape::Scalar` domain (bare `name: ""`, `public.eql_v3_json`) +/// is a ciphertext-only storage domain and IS generated — by the scalar +/// materializer, exactly like `public.eql_v3_boolean`. It is why the family is +/// "mixed": `families_with_scalar_domains()` renders its scalar domain(s) while +/// `scalar_families()` still excludes the family wholesale (`is_scalar()` is +/// `.all()`), leaving the hand-written SteVec surface untouched. The +/// scalar/SteVec coupling is pinned by `tests::shape_and_terms_are_consistent`. +/// +/// Naming: the bare storage domain is `public.eql_v3_json` (bare = storage, +/// like every scalar), and the searchable SteVec **document** carries the +/// `search` suffix (`public.eql_v3_json_search`), mirroring text's `_search`. +const JSON_DOMAINS: &[Domain] = &[ Domain { - // The established document name `public.eql_v3_json` predates the catalog and - // does not follow the family+suffix convention (family is "jsonb", not - // "json") — an explicit literal name, not the empty-suffix - // bare-family-name convention every scalar storage domain uses. - // `Domain::full_name` special-cases the name `"json"` to return it - // verbatim instead of concatenating. - name: "json", + // The searchable SteVec document: `public.eql_v3_json_search`. The + // `search` suffix follows the standard family+suffix convention (like + // text's `_search`); the bare `public.eql_v3_json` name belongs to the + // storage domain below. + name: "search", terms: &[], shape: Shape::SteVec, }, @@ -478,38 +492,72 @@ const JSONB_DOMAINS: &[Domain] = &[ terms: &[], shape: Shape::SteVec, }, + // Bare ciphertext-only storage domain `public.eql_v3_json`: a flat `{v,i,c}` + // envelope with a root ciphertext and NO SEM index terms (encrypt-at-rest, + // decrypt-in-proxy, never searched server-side) — structurally a scalar, NOT + // SteVec. `Shape::Scalar` (so `full_name("json")` → `json` → + // `sql_typname` → `eql_v3_json`, following the uniform prefix convention), + // generated by the scalar materializer like every other storage-only domain + // (cf. `public.eql_v3_boolean`). It is APPENDED (index 3) so the SteVec + // domains keep indices 0-2 that the index-based `spec` tests rely on. The + // family stays non-scalar (`is_scalar()` is `.all()`), so `scalar_families()` + // still excludes it and the hand-written SteVec SQL/bindings are untouched; + // only the new `families_with_scalar_domains()` seam picks up this one domain. + Domain { + name: "", + terms: &[], + shape: Shape::Scalar, + }, ]; -/// `jsonb` — the encrypted-JSONB (SteVec) family: `public.eql_v3_json` (document, the -/// one explicit-name exception — see `JSONB_DOMAINS`), `public.eql_v3_jsonb_entry` -/// (one sv element), `public.query_jsonb` (containment needle). The Rust -/// struct *bodies* are hand-written (`crates/eql-bindings/src/v3/jsonb.rs`, -/// not derivable from the catalog); `Domain::rust_struct_name` derives their -/// *identifiers* (`SteVecDocument`/`SteVecEntry`/`SteVecQuery`) from -/// `Domain.name` so codegen's inventory renderer doesn't need its own copy of -/// the mapping. Added to `CATALOG` at the flip task. -pub const JSONB: DomainFamily = DomainFamily { - name: "jsonb", - domains: JSONB_DOMAINS, +/// `json` — the encrypted-JSON family (a **mixed** family). Three hand-written +/// SteVec domains: `public.eql_v3_json_search` (searchable document), +/// `public.eql_v3_json_entry` (one sv element), `eql_v3.query_json` (containment +/// needle); their Rust struct *bodies* are hand-written +/// (`crates/eql-bindings/src/v3/json.rs`, not derivable from the catalog), while +/// `Domain::rust_struct_name` derives their *identifiers* +/// (`SteVecDocument`/`SteVecEntry`/`SteVecQuery`) from `Domain.name`. Plus one +/// generated `Shape::Scalar` storage domain, `public.eql_v3_json` +/// (ciphertext-only, no index terms), materialized like every other +/// storage-only scalar. +pub const JSON: DomainFamily = DomainFamily { + name: "json", + domains: JSON_DOMAINS, }; /// The domain-family catalog — the single source of truth. Includes both the -/// scalar (flat) families and the non-scalar SteVec `jsonb` family; scalar-only -/// consumers should iterate [`scalar_families`] instead. Order is significant -/// (it drives inventory/generation order). New types are appended as their SQL -/// surface lands. +/// scalar (flat) families and the mixed `json` family (SteVec domains + a bare +/// scalar storage domain); scalar-only consumers should iterate +/// [`scalar_families`] instead. Order is significant (it drives +/// inventory/generation order). New types are appended as their SQL surface +/// lands. pub const CATALOG: &[DomainFamily] = &[ - INTEGER, SMALLINT, BIGINT, DATE, TIMESTAMP, NUMERIC, TEXT, BOOLEAN, REAL, DOUBLE, JSONB, + INTEGER, SMALLINT, BIGINT, DATE, TIMESTAMP, NUMERIC, TEXT, BOOLEAN, REAL, DOUBLE, JSON, ]; /// The scalar (flat) families of `CATALOG`, in order — everything except the -/// SteVec `jsonb` family. The DRY entry point for the ~9 scalar-only consumers -/// (`generate_all`, `list-types`, the scalar matrix) so they never re-inline the -/// `is_scalar()` filter. +/// mixed `json` family (which is non-scalar because it carries SteVec domains). +/// The DRY entry point for the ~9 scalar-only consumers (`list-types`, the +/// scalar matrix) so they never re-inline the `is_scalar()` filter. pub fn scalar_families() -> impl Iterator { CATALOG.iter().filter(|f| f.is_scalar()) } +/// The families of `CATALOG` that contain **at least one** scalar (flat) domain, +/// in order. A superset of [`scalar_families`]: it additionally admits *mixed* +/// families (a family that is not wholly scalar but has some scalar domain — the +/// `json` family, whose bare `public.eql_v3_json` storage domain is scalar +/// while its SteVec domains are not). The seam the SQL/bindings materializers +/// iterate: they render each family's scalar domains and skip its non-scalar +/// ones, so a fully-scalar family is handled identically to before, and a mixed +/// family contributes only its scalar surface. Callers pair this with a +/// per-domain `d.is_scalar()` filter. +pub fn families_with_scalar_domains() -> impl Iterator { + CATALOG + .iter() + .filter(|f| f.domains.iter().any(|d| d.is_scalar())) +} + #[cfg(test)] mod tests; diff --git a/crates/eql-domains/src/spec.rs b/crates/eql-domains/src/spec.rs index b88b21935..8d9987396 100644 --- a/crates/eql-domains/src/spec.rs +++ b/crates/eql-domains/src/spec.rs @@ -13,22 +13,18 @@ impl Domain { /// the `_` join — codegen builds every domain name through this, so the /// "domain name starts with the family name" rule is structural. /// - /// Two documented exceptions, both on the `jsonb` family: + /// One documented exception, on the `json` family: /// - /// - the document domain (`public.eql_v3_json`, `Domain.name == "json"`) predates - /// the catalog and doesn't follow the family+suffix convention - /// (`family_name` is `"jsonb"`, not `"json"`), so its `name` is returned - /// verbatim instead of being joined; /// - the containment needle (`Domain.name == "query"`) follows the - /// query-operand PREFIX convention (CIP-3442): `query_jsonb`, matching + /// query-operand PREFIX convention (CIP-3442): `query_json`, matching /// the scalar `query_` twins so every query-operand type sorts /// apart from the column domains in alphabetical type listings. /// - /// Every other domain — scalar or the SteVec entry — uses the join. + /// Every other domain uses the join — including the `json` family's bare + /// storage domain (`""` => `json` => `public.eql_v3_json`) and its + /// searchable SteVec document (`"search"` => `json_search` => + /// `public.eql_v3_json_search`). pub fn full_name(&self, family_name: &str) -> String { - if matches!(self.shape, crate::Shape::SteVec) && self.name == "json" { - return self.name.to_string(); - } if matches!(self.shape, crate::Shape::SteVec) && self.name == "query" { return format!("query_{family_name}"); } @@ -43,7 +39,7 @@ impl Domain { /// installed. Public-schema column domains carry the /// [`crate::PUBLIC_TYPNAME_PREFIX`] version prefix /// (`eql_v3_integer_eq`, `eql_v3_json` — CIP-3472); the SteVec containment - /// needle (`query_jsonb`) lives in the `eql_v3` schema, which already + /// needle (`query_json`) lives in the `eql_v3` schema, which already /// versions it, so it stays bare like the scalar `query_` twins. /// The **single** site that owns the prefix decision — codegen (SQL + /// bindings) and the eql-bindings parity tests both resolve installed @@ -83,7 +79,7 @@ impl Domain { } /// True when this domain carries the flat scalar payload shape. False for - /// the SteVec shapes (the `jsonb` family). The per-domain primitive that + /// the SteVec shapes (the `json` family). The per-domain primitive that /// [`DomainFamily::is_scalar`] and [`crate::scalar_families`] are built on — /// most scalar-only consumers filter through those family-level helpers, not /// this predicate directly (the `ts_property_order` guard is the exception). @@ -95,16 +91,16 @@ impl Domain { /// shape-aware, unlike [`Self::struct_ident`]. For [`crate::Shape::Scalar`] /// this is exactly `struct_ident` (derived from the domain name). The /// SteVec shapes' struct bodies are hand-written (not name-derivable — see - /// `crates/eql-bindings/src/v3/jsonb.rs`), but their identifiers ARE + /// `crates/eql-bindings/src/v3/json.rs`), but their identifiers ARE /// name-derivable (`"SteVec" + capitalize(name)`), with one irregular case: - /// the document domain's established name `"json"` maps to `SteVecDocument`, - /// not `SteVecJson` (mirroring the exception `full_name` already carries). + /// the searchable document domain's name `"search"` maps to `SteVecDocument`, + /// not `SteVecSearch` (the struct is named for what it is — the document). /// The SINGLE source of truth for that mapping — `eql-codegen`'s inventory /// renderer calls this instead of carrying its own copy of the shape match. pub fn rust_struct_name(&self, family_name: &str) -> String { match self.shape { crate::Shape::Scalar => self.struct_ident(family_name), - crate::Shape::SteVec if self.name == "json" => "SteVecDocument".to_string(), + crate::Shape::SteVec if self.name == "search" => "SteVecDocument".to_string(), crate::Shape::SteVec => format!("SteVec{}", capitalize(self.name)), } } @@ -137,7 +133,7 @@ impl DomainFamily { /// testing `ord` suffices. /// /// A **flat-scalar** predicate: it describes the storage/`_eq`/`_ord` shape, - /// which the non-scalar SteVec `jsonb` family does not have (its ordered `op` + /// which the non-scalar SteVec `json` family does not have (its ordered `op` /// capability is carried structurally, not as an `ord` domain). So it is /// guarded by [`Self::is_scalar`] — a non-scalar family is never "eq-only", /// even though it happens to declare no domain literally named `ord`. @@ -166,7 +162,7 @@ impl DomainFamily { } /// True when every domain in this family is [`crate::Shape::Scalar`] — i.e. it - /// is a flat scalar family, not the SteVec `jsonb` family. + /// is a flat scalar family, not the SteVec `json` family. pub fn is_scalar(&self) -> bool { self.domains.iter().all(|d| d.is_scalar()) } @@ -222,38 +218,38 @@ mod tests { #[test] fn scalar_families_exclude_non_scalar_families_after_jsonb_flip() { - use crate::{scalar_families, CATALOG, JSONB}; + use crate::{scalar_families, CATALOG, JSON}; let names: Vec<&str> = scalar_families().map(|f| f.name).collect(); assert_eq!(names.len(), CATALOG.len() - 1); - assert!(!names.contains(&JSONB.name)); + assert!(!names.contains(&JSON.name)); for f in scalar_families() { assert!(f.is_scalar()); } } #[test] - fn jsonb_domain_names_follow_the_documented_conventions() { - // The entry carries the family+suffix naming every scalar family uses. - // The document is one documented exception — its established name - // `json` doesn't match the family name `jsonb`, so `full_name` returns - // it verbatim rather than concatenating. The containment needle is the - // other — it follows the query-operand PREFIX convention (CIP-3442), - // like the scalar `query_` twins. Real SQL names: - // public.eql_v3_json, public.eql_v3_jsonb_entry, eql_v3.query_jsonb — - // the public column domains carry the version prefix (CIP-3472); the - // needle lives in the already-versioned `eql_v3` schema, so it stays - // bare. - use crate::JSONB; - assert_eq!(JSONB.domain_name(&JSONB.domains[0]), "eql_v3_json"); - assert_eq!(JSONB.domain_name(&JSONB.domains[1]), "eql_v3_jsonb_entry"); - assert_eq!(JSONB.domain_name(&JSONB.domains[2]), "query_jsonb"); + fn json_domain_names_follow_the_documented_conventions() { + // Every json column domain uses the family+suffix naming (like every + // scalar family): the bare storage domain is `eql_v3_json`, the + // searchable document is `eql_v3_json_search`, the entry is + // `eql_v3_json_entry`. The containment needle is the one exception — it + // follows the query-operand PREFIX convention (CIP-3442), like the + // scalar `query_` twins. The public column domains carry the + // version prefix (CIP-3472); the needle lives in the already-versioned + // `eql_v3` schema, so it stays bare. + use crate::JSON; + assert_eq!(JSON.domain_name(&JSON.domains[0]), "eql_v3_json_search"); + assert_eq!(JSON.domain_name(&JSON.domains[1]), "eql_v3_json_entry"); + assert_eq!(JSON.domain_name(&JSON.domains[2]), "query_json"); + // The bare storage domain (index 3) is the plain `eql_v3_json`. + assert_eq!(JSON.domain_name(&JSON.domains[3]), "eql_v3_json"); } #[test] fn rust_struct_name_is_shape_aware() { // Scalar: derived, same as struct_ident. Non-scalar: the hand-written // SteVec struct names — the ONE place these two universes diverge. - use crate::JSONB; + use crate::JSON; let integer_eq = Domain { name: "eq", terms: &[Term::Hm], @@ -261,25 +257,26 @@ mod tests { }; assert_eq!(integer_eq.rust_struct_name("integer"), "IntegerEq"); assert_eq!( - JSONB.domains[0].rust_struct_name(JSONB.name), + JSON.domains[0].rust_struct_name(JSON.name), "SteVecDocument" ); - assert_eq!(JSONB.domains[1].rust_struct_name(JSONB.name), "SteVecEntry"); - assert_eq!(JSONB.domains[2].rust_struct_name(JSONB.name), "SteVecQuery"); + assert_eq!(JSON.domains[1].rust_struct_name(JSON.name), "SteVecEntry"); + assert_eq!(JSON.domains[2].rust_struct_name(JSON.name), "SteVecQuery"); + // The bare storage domain's struct is the flat scalar `Json`. + assert_eq!(JSON.domains[3].rust_struct_name(JSON.name), "Json"); } #[test] - fn is_eq_only_is_false_for_the_non_scalar_jsonb_family() { + fn is_eq_only_is_false_for_the_non_scalar_json_family() { // `is_eq_only` describes the flat-scalar shape (storage + `_eq`, no - // `_ord`). The non-scalar jsonb family has no flat eq/ord concept — its - // ordered `oc` capability is carried structurally, not as an `ord` - // domain — so a bare `!any(name == "ord")` would misreport it as - // eq-only. It must return false. Guards the latent footgun where jsonb - // gets wired into the eq-only-sensitive matrix macros. - use crate::JSONB; + // `_ord`). The mixed json family has no flat eq/ord concept for its + // SteVec domains — their ordered `op` capability is carried + // structurally, not as an `ord` domain — so a bare `!any(name == "ord")` + // would misreport it. It must return false (the family is non-scalar). + use crate::JSON; assert!( - !JSONB.is_eq_only(), - "the non-scalar jsonb family must not be classified eq-only" + !JSON.is_eq_only(), + "the non-scalar json family must not be classified eq-only" ); } } diff --git a/crates/eql-domains/src/tests.rs b/crates/eql-domains/src/tests.rs index aae47b124..774ad646f 100644 --- a/crates/eql-domains/src/tests.rs +++ b/crates/eql-domains/src/tests.rs @@ -652,7 +652,7 @@ mod catalog_tests { "boolean", "real", "double", - "jsonb" + "json" ] ); } @@ -1050,7 +1050,7 @@ mod catalog_tests { "boolean" => ScalarKind::Bool, "real" => ScalarKind::F32, "double" => ScalarKind::F64, - "jsonb" => ScalarKind::Jsonb, + "json" => ScalarKind::Jsonb, other => panic!("unmapped scalar token {other} in FIXTURES"), }; assert_eq!( @@ -1309,18 +1309,13 @@ mod invariant_tests { fn every_domain_name_starts_with_its_family_name() { for s in CATALOG { for d in s.domains { - // The one documented exception: `public.eql_v3_json` (the jsonb - // family's document domain) predates the catalog and keeps - // its established name rather than following the - // family+suffix convention — see `Domain::full_name`. - if s.name == "jsonb" && d.name == "json" { - continue; - } - // The jsonb containment needle follows the query-operand - // PREFIX convention (CIP-3442) instead: `query_`, - // matching the scalar `query_` twins — see - // `Domain::full_name`. - if s.name == "jsonb" && d.name == "query" { + // The one documented exception: the json containment needle + // follows the query-operand PREFIX convention (CIP-3442): + // `query_`, matching the scalar `query_` twins — + // see `Domain::full_name`. (Every other json domain — bare + // storage, `_search` document, `_entry` — follows the standard + // family+suffix join.) + if s.name == "json" && d.name == "query" { assert_eq!(s.domain_name(d), format!("query_{}", s.name)); continue; } @@ -1533,15 +1528,22 @@ mod shape_tests { #[test] fn jsonb_family_is_non_scalar_and_in_catalog_after_flip() { - use crate::{Shape, CATALOG, JSONB}; - assert!(!JSONB.is_scalar()); - assert_eq!(JSONB.domains.len(), 3); - assert!(matches!(JSONB.domains[0].shape, Shape::SteVec)); - assert_eq!(JSONB.domains[0].name, "json"); - assert!(JSONB.domains.iter().all(|d| d.terms.is_empty())); + use crate::{Shape, CATALOG, JSON}; + // Mixed family: three SteVec domains (indices 0-2) + one appended bare + // scalar storage domain (index 3, `public.eql_v3_json`). The family is + // still non-scalar because `is_scalar()` is `.all()`. + assert!(!JSON.is_scalar()); + assert_eq!(JSON.domains.len(), 4); + assert!(matches!(JSON.domains[0].shape, Shape::SteVec)); + assert_eq!(JSON.domains[0].name, "search"); + // The appended storage domain is the sole scalar: bare name, empty terms. + assert!(matches!(JSON.domains[3].shape, Shape::Scalar)); + assert_eq!(JSON.domains[3].name, ""); + assert_eq!(JSON.domains.iter().filter(|d| d.is_scalar()).count(), 1); + assert!(JSON.domains.iter().all(|d| d.terms.is_empty())); assert!( - CATALOG.iter().any(|f| f.name == "jsonb"), - "JSONB must be catalogued at the flip" + CATALOG.iter().any(|f| f.name == "json"), + "JSON must be catalogued at the flip" ); } } diff --git a/docs/reference/adding-a-scalar-encrypted-domain-type.md b/docs/reference/adding-a-scalar-encrypted-domain-type.md index 29491cae9..d4dcbdfd4 100644 --- a/docs/reference/adding-a-scalar-encrypted-domain-type.md +++ b/docs/reference/adding-a-scalar-encrypted-domain-type.md @@ -28,8 +28,10 @@ validated by the compiler plus catalog `#[test]`s. The reference type is `public.eql_v3_integer`; `public.eql_v3_text` is the worked non-integer example (ordered + equality + a `match` capability via the `Bloom` term); `public.eql_v3_boolean` is the worked **storage-only / encryption-only** example (a single term-less domain, no -searchable surface — see §8). **`jsonb` remains out of scope** for this -materializer (see §7). +searchable surface — see §8). **`jsonb` is a mixed family**: its searchable +SteVec domains stay hand-written and out of scope, but its ciphertext-only +storage domain `public.eql_v3_json` **is** materialized here like any +storage-only scalar (see §7). --- @@ -943,7 +945,7 @@ regenerate and commit the affected SQL files under --- -## 7. `text` (in scope) and `jsonb` (out of scope) +## 7. `text` (in scope) and `jsonb` (mixed: SteVec out of scope, storage domain in scope) `text` **is** materialised through this generator. It is the worked example of an ordered, non-integer, unbounded scalar: it hand-writes its `impl ScalarType` @@ -960,12 +962,22 @@ bloom-filter containment on the `public.eql_v3_text_match` domain) on top of equ probabilistic ngram-bloom containment, exposed only on `text_match`, and never backs equality. -`jsonb` remains **out of scope**. The `ScalarKind`/`Fixture` enums carry its -string-backed shape at the capability layer, but no `jsonb` SQL surface is -generated by *this* materializer — it needs a separate SQL design beyond the -ordered-scalar materializer. Encrypted-JSONB behaviour lives on the hand-written -`public.eql_v3_json` SteVec document domain (`src/v3/jsonb/`), not the scalar -materializer. +`jsonb` is a **mixed** family. Its **searchable** SteVec surface remains out of +scope for this materializer: the `public.eql_v3_json_search` document, `eql_v3_json_entry`, +and `eql_v3.query_json` domains carry `Shape::SteVec`, need a SQL design beyond +the ordered-scalar materializer, and stay hand-written under `src/v3/json/`. +But the family **also** carries one `Shape::Scalar` storage domain, +`public.eql_v3_json` — a bare ciphertext-only, storage-only encrypted-JSON blob +(the JSON analogue of `boolean` in §8), with no index terms and every native +jsonb operator blocked. That one domain **is** generated by this materializer, +into `src/v3/scalars/json/`, exactly like any storage-only scalar. The generator +picks it up because its SQL/bindings drivers iterate `families_with_scalar_domains()` +(any family with ≥1 scalar domain) and render each family's scalar domains only; +the family stays non-scalar (`is_scalar()` is `.all()`), so `scalar_families()` — +used by `list-types` and the SQLx matrix — still excludes it, keeping `jsonb` out +of the operator/coverage matrix. Use `public.eql_v3_json_search` when you need to search +encrypted JSON; `public.eql_v3_json` when you only need to store and round-trip +an encrypted JSON value. --- diff --git a/docs/reference/catalog-driven-architecture.md b/docs/reference/catalog-driven-architecture.md index c6338da63..f1b31d9b4 100644 --- a/docs/reference/catalog-driven-architecture.md +++ b/docs/reference/catalog-driven-architecture.md @@ -191,15 +191,15 @@ flowchart LR | `text` | Text | text-search (equality always routes through `Hm` — ORE is not equality-lossless for text) | | `boolean` | Bool | storage-only (2-value cardinality leak → no searchable index) | -**`jsonb` sits outside this classification.** It carries three domains — `public.eql_v3_json` -(document), `public.eql_v3_jsonb_entry` (one `sv` leaf), `eql_v3.query_jsonb` (containment +**`jsonb` sits outside this classification.** It carries three domains — `public.eql_v3_json_search` +(document), `public.eql_v3_json_entry` (one `sv` leaf), `eql_v3.query_json` (containment needle) — each tagged `Shape::SteVec` rather than `Shape::Scalar`, with an empty flat `terms` list: capability lives *structurally* inside the payload (per-`sv`-leaf `hm` XOR `op`), not as a family-level `Term` set. `Domain.name` (`"json"`/`"entry"`/`"query"`) disambiguates which of the three a given domain is — see `Domain::rust_struct_name`. `scalar_families()` filters `CATALOG` down to the `Shape::Scalar` rows, so `jsonb` never reaches `every_type_uses_a_known_domain_shape`, the ordered-scalar materializer (§3), or -the scalar SQLx matrix. Its SQL surface is hand-written under `src/v3/jsonb/` +the scalar SQLx matrix. Its SQL surface is hand-written under `src/v3/json/` (`eql-codegen` renders SQL only for `scalar_families()`) and its Rust structs are hand-written in `crates/eql-bindings/src/v3/jsonb.rs` — only inventory membership and `CATALOG` order are catalog-driven. This is also why the class diagram in §2.1 lists diff --git a/docs/reference/database-indexes.md b/docs/reference/database-indexes.md index de4f29fe3..7dbed0cec 100644 --- a/docs/reference/database-indexes.md +++ b/docs/reference/database-indexes.md @@ -176,7 +176,7 @@ Why the raw column does not scale: `GROUP BY col` uses the entire encrypted payl ### Field-level equality index (ste_vec elements) -For `GROUP BY` / `DISTINCT` / equality on a value extracted from an `public.eql_v3_json` document — e.g. `doc -> 'email'` — index the extractor applied to the selector. The extracted entry is an `public.eql_v3_jsonb_entry`, and `=` on it inlines to `eql_v3.eq_term(a) = eql_v3.eq_term(b)`: +For `GROUP BY` / `DISTINCT` / equality on a value extracted from an `public.eql_v3_json_search` document — e.g. `doc -> 'email'` — index the extractor applied to the selector. The extracted entry is an `public.eql_v3_json_entry`, and `=` on it inlines to `eql_v3.eq_term(a) = eql_v3.eq_term(b)`: ```sql CREATE INDEX users_data_email_eq @@ -187,7 +187,7 @@ SELECT count(*) FROM users GROUP BY eql_v3.eq_term(data_encrypted -> ''::text); SELECT * FROM users - WHERE data_encrypted -> ''::text = $1::public.eql_v3_jsonb_entry; + WHERE data_encrypted -> ''::text = $1::public.eql_v3_json_entry; ``` For ordered field-level access, index `eql_v3.ord_term(doc -> ''::text)` (a btree) and write `ORDER BY eql_v3.ord_term(doc -> ''::text)` — the same sort-key rule as above. The extracted CLLW-OPE term is a bytea domain that orders under the DEFAULT btree operator class, so this index needs no superuser-installed operator class (it works on Supabase / managed Postgres). The `` value is the deterministic selector hash the crypto layer emits in each `sv` element's `s` field, not a plaintext JSONPath. The operand on `->` must be typed (`-> ''::text`); a bare untyped literal falls through to native `jsonb ->`. @@ -196,18 +196,18 @@ For ordered field-level access, index `eql_v3.ord_term(doc -> ''::text ## GIN Indexes for JSONB Containment -For document-level containment (`@>` / `<@`) on `public.eql_v3_json` columns, use a GIN index over the ste_vec query shape. The typed `@>` overload inlines to a native `jsonb @>` over `eql_v3.to_ste_vec_query(col)::jsonb`, so a GIN index on the same expression engages: +For document-level containment (`@>` / `<@`) on `public.eql_v3_json_search` columns, use a GIN index over the ste_vec query shape. The typed `@>` overload inlines to a native `jsonb @>` over `eql_v3.to_ste_vec_query(col)::jsonb`, so a GIN index on the same expression engages: ```sql CREATE INDEX orders_data_gin ON orders USING gin (eql_v3.to_ste_vec_query(data_encrypted)::jsonb jsonb_path_ops); ANALYZE orders; -SELECT * FROM orders WHERE data_encrypted @> $1::eql_v3.query_jsonb; +SELECT * FROM orders WHERE data_encrypted @> $1::eql_v3.query_json; -- Bitmap Index Scan on orders_data_gin ``` -The needle must be typed — `$1::eql_v3.query_jsonb`, another `public.eql_v3_json`, or an `public.eql_v3_jsonb_entry`. A bare untyped literal falls through to native `jsonb @>`. +The needle must be typed — `$1::eql_v3.query_json`, another `public.eql_v3_json_search`, or an `public.eql_v3_json_entry`. A bare untyped literal falls through to native `jsonb @>`. ### GIN vs B-tree / hash @@ -267,7 +267,7 @@ A `hash` functional index on a 10M-row encrypted-JSONB column has been observed ### The de-TOAST floor -A functional index over a large encrypted column [de-TOASTs](https://www.postgresql.org/docs/current/storage-toast.html) the whole stored value once per row to evaluate the extractor — and an `public.eql_v3_json` document is large. This cost is unavoidable and identical across access methods; it sets the build's *floor* rate. (There is no partial de-TOAST — `doc -> 'selector'::text` materialises the entire document.) +A functional index over a large encrypted column [de-TOASTs](https://www.postgresql.org/docs/current/storage-toast.html) the whole stored value once per row to evaluate the extractor — and an `public.eql_v3_json_search` document is large. This cost is unavoidable and identical across access methods; it sets the build's *floor* rate. (There is no partial de-TOAST — `doc -> 'selector'::text` materialises the entire document.) ### Storage matters more than it does for queries @@ -325,7 +325,7 @@ Once a plan looks right, repeat with `EXPLAIN ANALYZE` to measure actual timings - [SQL support matrix](./sql-support.md) — which operators work against which domain variant. - [EQL Functions Reference](./eql-functions.md) — complete function API. -- [EQL with JSON and JSONB](./json-support.md) — `public.eql_v3_json` worked examples. +- [EQL with JSON and JSONB](./json-support.md) — `public.eql_v3_json_search` worked examples. - [Configuration Tutorial](../tutorials/proxy-configuration.md) — setting up encrypted columns end to end. --- diff --git a/docs/reference/eql-functions.md b/docs/reference/eql-functions.md index 42f6fcfe3..b1c5f55b5 100644 --- a/docs/reference/eql-functions.md +++ b/docs/reference/eql-functions.md @@ -1,6 +1,6 @@ # EQL Functions Reference -A reference for the functions and operators EQL exposes for querying encrypted data in PostgreSQL. The surface lives in the **`eql_v3`** schema and is organised around the per-scalar encrypted-domain types (`public.` and variants) and the encrypted-JSON document type (`public.eql_v3_json`). +A reference for the functions and operators EQL exposes for querying encrypted data in PostgreSQL. The surface lives in the **`eql_v3`** schema and is organised around the per-scalar encrypted-domain types (`public.` and variants) and the encrypted-JSON document type (`public.eql_v3_json_search`). > **There is no database-side configuration API.** Which index terms a value carries is chosen by the encryption client ([CipherStash Proxy](https://github.com/cipherstash/proxy) / [CipherStash Stack](https://github.com/cipherstash/stack)); a column's capability is fixed by the **domain variant** you type it as. See [SQL support matrix](./sql-support.md) for the variant/operator table. @@ -9,7 +9,7 @@ A reference for the functions and operators EQL exposes for querying encrypted d - [Operators](#operators) - [Function Equivalents](#function-equivalents) - [Index Term Extraction](#index-term-extraction) -- [Encrypted JSON (`public.eql_v3_json`)](#encrypted-json-eql_v3json) +- [Encrypted JSON (`public.eql_v3_json_search`)](#encrypted-json-eql_v3json) - [Aggregate Functions](#aggregate-functions) --- @@ -51,9 +51,9 @@ SELECT * FROM docs WHERE encrypted_content @> $1::public.eql_v3_text_match; `LIKE` / `ILIKE` (`~~` / `~~*`) are **not** part of the `eql_v3` surface — use `@>`. -### JSON containment / path — `public.eql_v3_json` +### JSON containment / path — `public.eql_v3_json_search` -`@>` / `<@`, `->` / `->>`, and the path functions on `public.eql_v3_json` are documented in [EQL with JSON and JSONB](./json-support.md). +`@>` / `<@`, `->` / `->>`, and the path functions on `public.eql_v3_json_search` are documented in [EQL with JSON and JSONB](./json-support.md). --- @@ -68,7 +68,7 @@ eql_v3.lt(a, b) -- < (on _ord / _ord_ore / text_search) eql_v3.lte(a, b) -- <= eql_v3.gt(a, b) -- > eql_v3.gte(a, b) -- >= -eql_v3.contains(a, b) -- @> (on text_match / text_search / public.eql_v3_json) +eql_v3.contains(a, b) -- @> (on text_match / text_search / public.eql_v3_json_search) eql_v3.contained_by(a, b) -- <@ ``` @@ -109,11 +109,11 @@ CREATE INDEX ON users USING gin (eql_v3.match_term(name_match)); > The full per-domain operator / wrapper / blocker surface (and the `public.` / `_eq` / `_ord` / `_ord_ope` / `_ord_ore` domain types themselves) is documented in [SQL support](./sql-support.md#encrypted-domain-scalar-types-publict) and the [scalar encrypted-domain type reference](./adding-a-scalar-encrypted-domain-type.md). -The `public.eql_v3_json` document type extracts entry-level terms with `eql_v3.eq_term(public.eql_v3_jsonb_entry)` and `eql_v3.ord_term(public.eql_v3_jsonb_entry)` — see [json-support.md](./json-support.md). +The `public.eql_v3_json_search` document type extracts entry-level terms with `eql_v3.eq_term(public.eql_v3_json_entry)` and `eql_v3.ord_term(public.eql_v3_json_entry)` — see [json-support.md](./json-support.md). --- -## Encrypted JSON (`public.eql_v3_json`) +## Encrypted JSON (`public.eql_v3_json_search`) The full encrypted-JSONB function surface — containment, `->` / `->>`, `eql_v3.jsonb_path_query` / `_first` / `_exists`, `eql_v3.jsonb_array_length` / `_elements` / `_elements_text`, `eql_v3.to_ste_vec_query`, `eql_v3.ste_vec_contains`, and the GIN helpers — is documented in **[EQL with JSON and JSONB](./json-support.md)**. @@ -146,7 +146,7 @@ SELECT eql_v3.max(price_encrypted) FROM products WHERE category = 'electronics'; SELECT eql_v3.min(price_jsonb::public.eql_v3_integer_ord) FROM products; ``` -`MIN` / `MAX` over a value extracted from an `public.eql_v3_json` document use `eql_v3.min(public.eql_v3_jsonb_entry)` / `max` — see [json-support.md](./json-support.md). +`MIN` / `MAX` over a value extracted from an `public.eql_v3_json_search` document use `eql_v3.min(public.eql_v3_json_entry)` / `max` — see [json-support.md](./json-support.md). `SUM` / `AVG` and other arithmetic aggregates are **not** supported on encrypted columns (they would require homomorphic encryption) — decrypt at the application boundary. `MIN` / `MAX` only need comparator-revealing terms. @@ -158,7 +158,7 @@ SELECT eql_v3.min(price_jsonb::public.eql_v3_integer_ord) FROM products; - [EQL Configuration Tutorial](../tutorials/proxy-configuration.md) — setting up encrypted columns end to end. - [Database Indexes](./database-indexes.md) — functional-index recipes and performance. -- [JSON/JSONB Support](./json-support.md) — `public.eql_v3_json` worked examples. +- [JSON/JSONB Support](./json-support.md) — `public.eql_v3_json_search` worked examples. - [SQL support matrix](./sql-support.md) — operators by domain variant. - [Payload / wire format](../../crates/eql-bindings/README.md) — canonical encrypted-payload wire types (envelope + index terms). - Client-side index configuration — [CipherStash Stack schema reference](https://cipherstash.com/docs/stack/cipherstash/encryption/schema). diff --git a/docs/reference/json-support.md b/docs/reference/json-support.md index 6a4fe72ff..1789b95b6 100644 --- a/docs/reference/json-support.md +++ b/docs/reference/json-support.md @@ -1,12 +1,12 @@ # EQL with JSON and JSONB -EQL encrypts, decrypts, and searches JSON / JSONB documents using structured encryption (ste_vec), exposed as the **`public.eql_v3_json`** document domain. An `public.eql_v3_json` column stores an encrypted document whose every path is searchable — without decryption — via containment, field/array access, and entry-level equality / range on extracted leaves. +EQL encrypts, decrypts, and searches JSON / JSONB documents using structured encryption (ste_vec), exposed as the **`public.eql_v3_json_search`** document domain. An `public.eql_v3_json_search` column stores an encrypted document whose every path is searchable — without decryption — via containment, field/array access, and entry-level equality / range on extracted leaves. ## On this page - [Storing encrypted JSON](#storing-encrypted-json) - [Typed operands (important)](#typed-operands-important) -- [Querying `public.eql_v3_json`](#querying-publicjson) +- [Querying `public.eql_v3_json_search`](#querying-publicjson) - [Containment queries (`@>`, `<@`)](#containment-queries) - [Field extraction (`jsonb_path_query`)](#field-extraction-jsonb_path_query) - [JSON path operators (`->`, `->>`)](#json-path-operators) @@ -17,12 +17,12 @@ EQL encrypts, decrypts, and searches JSON / JSONB documents using structured enc ## Storing encrypted JSON -Type the column as `public.eql_v3_json`. There is no database-side `add_search_config` step — which terms a document carries is decided by the encryption client ([CipherStash Proxy](https://github.com/cipherstash/proxy) / [CipherStash Stack](https://github.com/cipherstash/stack)); typing the column as `public.eql_v3_json` is what makes the encrypted operators and functions resolve. +Type the column as `public.eql_v3_json_search`. There is no database-side `add_search_config` step — which terms a document carries is decided by the encryption client ([CipherStash Proxy](https://github.com/cipherstash/proxy) / [CipherStash Stack](https://github.com/cipherstash/stack)); typing the column as `public.eql_v3_json_search` is what makes the encrypted operators and functions resolve. ```sql CREATE TABLE users ( id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY, - encrypted_json public.eql_v3_json + encrypted_json public.eql_v3_json_search ); ``` @@ -36,31 +36,31 @@ The stored value is the encrypted ste_vec document — an envelope (`v`, `i`, `c ## Typed operands (important) -`public.eql_v3_json` is a PostgreSQL **domain over `jsonb`**. PostgreSQL resolves `domain OP untyped_literal` to the **native** `jsonb` operator, because it flattens the domain to its base type when the right-hand side is an unknown-typed literal. A bare literal therefore **bypasses the encrypted operator (and the blockers) and silently returns native jsonb semantics** — typically a root-key lookup that yields `NULL` — instead of querying the encrypted document or raising. +`public.eql_v3_json_search` is a PostgreSQL **domain over `jsonb`**. PostgreSQL resolves `domain OP untyped_literal` to the **native** `jsonb` operator, because it flattens the domain to its base type when the right-hand side is an unknown-typed literal. A bare literal therefore **bypasses the encrypted operator (and the blockers) and silently returns native jsonb semantics** — typically a root-key lookup that yields `NULL` — instead of querying the encrypted document or raising. Always give the operand a known type: ```sql -- ✅ correct — typed operand resolves to the eql_v3 operator WHERE doc -> 'email'::text = $1 -WHERE doc @> $1::eql_v3.query_jsonb +WHERE doc @> $1::eql_v3.query_json WHERE doc -> $1 -- a text parameter (the CipherStash Proxy interface) -- ⚠ wrong — bare untyped literal resolves to native jsonb -> text, returns NULL WHERE doc -> 'email' ``` -This is **intrinsic to the domain type-kind**, not a bug: the only way to remove it would be to make `public.eql_v3_json` a base type (losing free `jsonb` interop). The CipherStash Proxy always passes typed parameters, so applications routing through the Proxy are unaffected; the caveat matters only for hand-written ad-hoc SQL. +This is **intrinsic to the domain type-kind**, not a bug: the only way to remove it would be to make `public.eql_v3_json_search` a base type (losing free `jsonb` interop). The CipherStash Proxy always passes typed parameters, so applications routing through the Proxy are unaffected; the caveat matters only for hand-written ad-hoc SQL. -## Querying `public.eql_v3_json` +## Querying `public.eql_v3_json_search` ### Containment queries (`@>`, `<@`) -`@>` tests whether the encrypted document contains a structure; `<@` is the reverse. The needle must be **typed** — another `public.eql_v3_json`, an `eql_v3.query_jsonb`, or an `public.eql_v3_jsonb_entry`: +`@>` tests whether the encrypted document contains a structure; `<@` is the reverse. The needle must be **typed** — another `public.eql_v3_json_search`, an `eql_v3.query_json`, or an `public.eql_v3_json_entry`: ```sql SELECT * FROM examples -WHERE encrypted_json @> $1::eql_v3.query_jsonb; +WHERE encrypted_json @> $1::eql_v3.query_json; ``` This is the encrypted equivalent of the plaintext `jsonb_column @> '{"top":{"nested":["a"]}}'`. @@ -72,7 +72,7 @@ CREATE INDEX examples_json_gin ON examples USING gin (eql_v3.to_ste_vec_query(encrypted_json)::jsonb jsonb_path_ops); ANALYZE examples; -SELECT * FROM examples WHERE encrypted_json @> $1::eql_v3.query_jsonb; +SELECT * FROM examples WHERE encrypted_json @> $1::eql_v3.query_json; ``` See [GIN Indexes for JSONB Containment](./database-indexes.md#gin-indexes-for-jsonb-containment) for the full setup. @@ -94,24 +94,24 @@ SELECT eql_v3.jsonb_path_exists(encrypted_json, 'abc123def456...') FROM examples ### JSON path operators (`->`, `->>`) -`->` returns the matched entry as an `public.eql_v3_jsonb_entry`; `->>` returns it serialized as `text` (ciphertext JSON, not decrypted plaintext). The selector operand must be typed: +`->` returns the matched entry as an `public.eql_v3_json_entry`; `->>` returns it serialized as `text` (ciphertext JSON, not decrypted plaintext). The selector operand must be typed: ```sql --- Field access by selector (returns public.eql_v3_jsonb_entry) +-- Field access by selector (returns public.eql_v3_json_entry) SELECT encrypted_json -> 'selector_hash'::text FROM examples; -- Field access as text (returns the entry as ciphertext text) SELECT encrypted_json ->> 'selector_hash'::text FROM examples; --- Array element by 0-based index (returns public.eql_v3_jsonb_entry) +-- Array element by 0-based index (returns public.eql_v3_json_entry) SELECT encrypted_json -> 0 FROM examples; ``` -The extracted `public.eql_v3_jsonb_entry` is itself comparable: `=` / `<>` resolve via `eql_v3.eq_term`, and `<` / `<=` / `>` / `>=` via `eql_v3.ord_term` (on String / Number leaves): +The extracted `public.eql_v3_json_entry` is itself comparable: `=` / `<>` resolve via `eql_v3.eq_term`, and `<` / `<=` / `>` / `>=` via `eql_v3.ord_term` (on String / Number leaves): ```sql SELECT * FROM examples -WHERE encrypted_json -> 'email_selector'::text = $1::public.eql_v3_jsonb_entry; +WHERE encrypted_json -> 'email_selector'::text = $1::public.eql_v3_json_entry; ``` ### Array operations @@ -137,16 +137,16 @@ FROM examples GROUP BY eql_v3.eq_term(encrypted_json -> 'color_selector'::text); ``` -`MIN` / `MAX` over an extracted ordered leaf use the `eql_v3.min(public.eql_v3_jsonb_entry)` / `max` aggregates. +`MIN` / `MAX` over an extracted ordered leaf use the `eql_v3.min(public.eql_v3_json_entry)` / `max` aggregates. ## `eql_v3` functions for JSONB and ste_vec ### Core functions - **`eql_v3.ste_vec(val jsonb) RETURNS jsonb[]`** — extracts the ste_vec index array from an encrypted payload. -- **`eql_v3.ste_vec_contains(a public.eql_v3_json, b public.eql_v3_json) RETURNS boolean`** — true if all ste_vec terms in `b` exist in `a`; backs the `@>` operator. -- **`eql_v3.to_ste_vec_query(val public.eql_v3_json) RETURNS eql_v3.query_jsonb`** — the GIN-indexable query shape `@>` inlines to. -- **`eql_v3.meta_data(val jsonb)`**, **`eql_v3.ciphertext(val jsonb)`**, **`eql_v3.selector(val jsonb)` / `(entry public.eql_v3_jsonb_entry)`** — envelope / ciphertext / selector accessors. +- **`eql_v3.ste_vec_contains(a public.eql_v3_json_search, b public.eql_v3_json_search) RETURNS boolean`** — true if all ste_vec terms in `b` exist in `a`; backs the `@>` operator. +- **`eql_v3.to_ste_vec_query(val public.eql_v3_json_search) RETURNS eql_v3.query_json`** — the GIN-indexable query shape `@>` inlines to. +- **`eql_v3.meta_data(val jsonb)`**, **`eql_v3.ciphertext(val jsonb)`**, **`eql_v3.selector(val jsonb)` / `(entry public.eql_v3_json_entry)`** — envelope / ciphertext / selector accessors. ### Path query functions @@ -162,15 +162,15 @@ GROUP BY eql_v3.eq_term(encrypted_json -> 'color_selector'::text); ### Entry comparison / aggregate -- **`eql_v3.eq_term(entry public.eql_v3_jsonb_entry)`** — equality term (backs `=` / `<>` / `GROUP BY`). -- **`eql_v3.ord_term(entry public.eql_v3_jsonb_entry)`** — ordering term (backs `<` … `>=`); returns SQL `NULL` when the leaf carries no `op` term. -- **`eql_v3.min(public.eql_v3_jsonb_entry)` / `eql_v3.max(...)`** — MIN / MAX over an extracted ordered leaf. +- **`eql_v3.eq_term(entry public.eql_v3_json_entry)`** — equality term (backs `=` / `<>` / `GROUP BY`). +- **`eql_v3.ord_term(entry public.eql_v3_json_entry)`** — ordering term (backs `<` … `>=`); returns SQL `NULL` when the leaf carries no `op` term. +- **`eql_v3.min(public.eql_v3_json_entry)` / `eql_v3.max(...)`** — MIN / MAX over an extracted ordered leaf. For GIN-indexable JSONB containment, see [GIN Indexes for JSONB Containment](./database-indexes.md#gin-indexes-for-jsonb-containment) (`eql_v3.to_ste_vec_query(col)::jsonb jsonb_path_ops`). ### Blocked operators -The native `jsonb` operators `?`, `?|`, `?&`, `@?`, `@@`, `#>`, `#>>`, `-`, `#-`, `||`, and root-document `=` `<>` `<` `<=` `>` `>=` are **blocked** on `public.eql_v3_json` — they `RAISE` rather than running plaintext-jsonb semantics on the encrypted payload. Use containment, field access, or the `eql_v3.jsonb_path_*` functions instead. +The native `jsonb` operators `?`, `?|`, `?&`, `@?`, `@@`, `#>`, `#>>`, `-`, `#-`, `||`, and root-document `=` `<>` `<` `<=` `>` `>=` are **blocked** on `public.eql_v3_json_search` — they `RAISE` rather than running plaintext-jsonb semantics on the encrypted payload. Use containment, field access, or the `eql_v3.jsonb_path_*` functions instead. ## How ste_vec indexing works @@ -197,7 +197,7 @@ Structured Encryption (ste_vec) makes a JSONB document searchable by: ```sql -- Find records where account.email = "alice@example.com" -WHERE encrypted_data @> $1::eql_v3.query_jsonb; +WHERE encrypted_data @> $1::eql_v3.query_json; ``` Encryption and selector generation are handled by CipherStash Proxy or CipherStash Stack, not by EQL directly. diff --git a/docs/reference/permissions.md b/docs/reference/permissions.md index e42f45224..9fa1d9cb9 100644 --- a/docs/reference/permissions.md +++ b/docs/reference/permissions.md @@ -58,9 +58,9 @@ needs `USAGE` on it anyway. The exact requirement is path-dependent: | Ordering (`<` `<=` `>` `>=` / `eql_v3.lt`…) | ✅ | ✅ | only on `_ord_ore` / `text_search_ore` | | `MIN` / `MAX` aggregates | ✅ | ✅ | only on `_ord_ore` / `text_search_ore` | | jsonb containment read (`@>` `<@` / `ste_vec_contains`) | ✅ | — | — | -| Cast/write raw JSON → `public.eql_v3_json` | ✅ | ✅ | — | +| Cast/write raw JSON → `public.eql_v3_json_search` | ✅ | ✅ | — | | Cast/write raw JSON → a scalar domain (`public.eql_v3_integer`…) | ✅ | — | — | -| Cast a query operand → `eql_v3.query_` / `eql_v3.query_jsonb` | ✅ | — | — | +| Cast a query operand → `eql_v3.query_` / `eql_v3.query_json` | ✅ | — | — | Why the internal grant is needed even though you only call public objects: @@ -79,9 +79,9 @@ Why the internal grant is needed even though you only call public objects: installer places in the `extensions` schema — hence the `USAGE` there. The CLLW-OPE variants (`_ord`, `_ord_ope`, `text_search`) compare native `bytea` and need no `extensions` grant. -- **Casting raw jsonb to `public.eql_v3_json` or `eql_v3.query_jsonb`** fires a +- **Casting raw jsonb to `public.eql_v3_json_search` or `eql_v3.query_json`** fires a domain `CHECK` that calls an `eql_v3_internal.is_valid_*` validator. (Scalar - domain CHECKs — and, since issue #354, the `public.eql_v3_jsonb_entry` CHECK — are + domain CHECKs — and, since issue #354, the `public.eql_v3_json_entry` CHECK — are pure structural jsonb tests, so casting to those domains needs no internal grant.) diff --git a/docs/reference/query-performance.md b/docs/reference/query-performance.md index a2a1dca01..7b4c6a561 100644 --- a/docs/reference/query-performance.md +++ b/docs/reference/query-performance.md @@ -8,7 +8,7 @@ Getting EQL-encrypted queries competitive with plain PostgreSQL comes down to on - [How index engagement works](./database-indexes.md#how-index-engagement-works) — extractor inlining and structural matching. - [Range queries and the `ORDER BY` sort-key trap](./database-indexes.md#range-queries-and-order-by) — write `ORDER BY` against the column's ordering extractor (`eql_v3.ord_term(col)` on `_ord`) to avoid a Sort node. - [`GROUP BY` / `DISTINCT`](./database-indexes.md#group-by--distinct) — group on `eql_v3.eq_term(col)`, not the raw column, to stay inside `work_mem`. -- [GIN indexes for JSONB containment](./database-indexes.md#gin-indexes-for-jsonb-containment) — `public.eql_v3_json` document search. +- [GIN indexes for JSONB containment](./database-indexes.md#gin-indexes-for-jsonb-containment) — `public.eql_v3_json_search` document search. - [Building indexes on large tables](./database-indexes.md#performance-building-indexes-on-large-tables) — `maintenance_work_mem`, btree-vs-hash build scaling, the de-TOAST floor. - [Diagnosing queries with `EXPLAIN`](./database-indexes.md#diagnosing-queries-with-explain). diff --git a/docs/reference/sql-support.md b/docs/reference/sql-support.md index c316b4c37..86db39771 100644 --- a/docs/reference/sql-support.md +++ b/docs/reference/sql-support.md @@ -5,7 +5,7 @@ This page summarises which SQL operators and language features work against EQL- EQL ships its searchable-encryption surface as PostgreSQL **domains in the `public` schema**: - **per-scalar encrypted-domain types** — `public.eql_v3_integer`, `public.eql_v3_text`, `public.eql_v3_timestamp`, … — one family of domain *variants* per scalar; and -- **an encrypted-JSON document type** — `public.eql_v3_json` — for structured-encryption (ste_vec) JSONB. +- **an encrypted-JSON document type** — `public.eql_v3_json_search` — for structured-encryption (ste_vec) JSONB. The capability of a column is fixed by the **domain variant you type it as**. There is no database-side `add_search_config` / `add_column` step: which index terms travel in a value's payload is decided by the encryption client ([CipherStash Proxy](https://github.com/cipherstash/proxy) / [CipherStash Stack](https://github.com/cipherstash/stack)), and the column's domain variant is what makes the matching operators resolve. Unsupported operators are not silent no-ops — they route to blocker functions that `RAISE` an "operator not supported" exception (a `NULL` operand still raises; the blockers are deliberately not `STRICT`). @@ -76,7 +76,7 @@ This matrix covers higher-level SQL constructs. As above, ✅ requires the colum | `WHERE col = …` / `<>` | | `_eq`, `_ord`, `text_search` | | `WHERE col <` / `<=` / `>` / `>=` | | `_ord`, `text_search` | | `WHERE col BETWEEN … AND …` | desugars to `>=` and `<=` | `_ord`, `text_search` | -| `WHERE col @> …` | bloom-filter token containment (text), or document containment (`public.eql_v3_json`) | `text_match`, `text_search`, `public.eql_v3_json` | +| `WHERE col @> …` | bloom-filter token containment (text), or document containment (`public.eql_v3_json_search`) | `text_match`, `text_search`, `public.eql_v3_json_search` | | `WHERE col IN (…)` | desugars to `=` | `_eq`, `_ord`, `text_search` | | `ORDER BY col` | meaningful only with an ordering term | `_ord`, `text_search` | | `GROUP BY col` / `DISTINCT` | needs an equality term | `_eq`, `_ord`, `text_search` | @@ -112,9 +112,9 @@ See [Database Indexes for Encrypted Columns](./database-indexes.md) for the full --- -## `public.eql_v3_json`: structured encryption for JSON +## `public.eql_v3_json_search`: structured encryption for JSON -`public.eql_v3_json` is the encrypted-JSON document domain (built on the structured-encryption "ste_vec" model). A JSONB document is encrypted into a searchable vector (`sv`) of terms — one element per path inside the document — each carrying: +`public.eql_v3_json_search` is the encrypted-JSON document domain (built on the structured-encryption "ste_vec" model). A JSONB document is encrypted into a searchable vector (`sv`) of terms — one element per path inside the document — each carrying: - `s` — a deterministic **selector** hash for the JSON path (always present); and - one or more **value terms** depending on the JSON type of the leaf at that path. @@ -135,24 +135,24 @@ The search capabilities available on a value extracted via `->` or `eql_v3.jsonb `hm` supports equality only; `op` is a CLLW OPE term that preserves order *and* collapses to equality on matching keys. JSON `null` here refers to a `null` literal *inside* the document — a SQL `NULL` column is not encrypted at all. -### Operators and functions on `public.eql_v3_json` +### Operators and functions on `public.eql_v3_json_search` | SQL form | Resolves to | Returns / notes | | -------------------------------- | -------------------------------------------------- | --------------- | -| `doc @> needle` / `needle <@ doc` | `eql_v3."@>"` / `eql_v3."<@"` | document containment; GIN-indexable via `eql_v3.to_ste_vec_query(doc)::jsonb` — see [GIN Indexes for JSONB Containment](./database-indexes.md#gin-indexes-for-jsonb-containment). `needle` must be typed (`$1::eql_v3.query_jsonb`, another `public.eql_v3_json`, or an `public.eql_v3_jsonb_entry`). | -| `doc -> 'sel'::text` / `doc -> N` | `eql_v3."->"` | field / 0-based array-element access; returns `public.eql_v3_jsonb_entry`. | +| `doc @> needle` / `needle <@ doc` | `eql_v3."@>"` / `eql_v3."<@"` | document containment; GIN-indexable via `eql_v3.to_ste_vec_query(doc)::jsonb` — see [GIN Indexes for JSONB Containment](./database-indexes.md#gin-indexes-for-jsonb-containment). `needle` must be typed (`$1::eql_v3.query_json`, another `public.eql_v3_json_search`, or an `public.eql_v3_json_entry`). | +| `doc -> 'sel'::text` / `doc -> N` | `eql_v3."->"` | field / 0-based array-element access; returns `public.eql_v3_json_entry`. | | `doc ->> 'sel'::text` | `eql_v3."->>"` | the matching entry serialized as `text` (ciphertext JSON, **not** decrypted plaintext). | -| extracted-leaf `=` `<>` | `eql_v3.eq_term(public.eql_v3_jsonb_entry)` | equality on a value extracted via `->` (e.g. `doc -> 'sel'::text = $1`). | -| extracted-leaf `<` `<=` `>` `>=` | `eql_v3.ord_term(public.eql_v3_jsonb_entry)` | ordered comparison on an extracted String / Number leaf. | -| `MIN` / `MAX` of extracted leaf | `eql_v3.min(public.eql_v3_jsonb_entry)` / `max` | over an extracted ordered leaf. | +| extracted-leaf `=` `<>` | `eql_v3.eq_term(public.eql_v3_json_entry)` | equality on a value extracted via `->` (e.g. `doc -> 'sel'::text = $1`). | +| extracted-leaf `<` `<=` `>` `>=` | `eql_v3.ord_term(public.eql_v3_json_entry)` | ordered comparison on an extracted String / Number leaf. | +| `MIN` / `MAX` of extracted leaf | `eql_v3.min(public.eql_v3_json_entry)` / `max` | over an extracted ordered leaf. | | `eql_v3.jsonb_path_query(doc, sel)` | path query | set-returning; yields encrypted entries. Also `jsonb_path_query_first`, `jsonb_path_exists`. | | `eql_v3.jsonb_array_length/elements/elements_text(doc)` | array helpers | length / set-returning elements / element text. | -> **Typed operands (important).** The selector / needle operand must carry a **known type** — a typed parameter (`$1`, which the Proxy supplies) or an explicit cast (`doc -> 'sel'::text`, `$1::eql_v3.query_jsonb`). A bare untyped literal (`doc -> 'sel'`) resolves to the **native `jsonb` operator** (PostgreSQL reduces the `public.eql_v3_json` domain to its `jsonb` base type for an unknown-typed RHS) and silently returns native jsonb semantics instead of the encrypted operator. +> **Typed operands (important).** The selector / needle operand must carry a **known type** — a typed parameter (`$1`, which the Proxy supplies) or an explicit cast (`doc -> 'sel'::text`, `$1::eql_v3.query_json`). A bare untyped literal (`doc -> 'sel'`) resolves to the **native `jsonb` operator** (PostgreSQL reduces the `public.eql_v3_json_search` domain to its `jsonb` base type for an unknown-typed RHS) and silently returns native jsonb semantics instead of the encrypted operator. ### Blocked JSONB operators -These native PostgreSQL JSONB operators are **blocked** on `public.eql_v3_json` (they `RAISE`, rather than falling through to native whole-document semantics): root-document `=` `<>` `<` `<=` `>` `>=`, and `?`, `?|`, `?&`, `@?`, `@@`, `#>`, `#>>`, `-`, `#-`, `||`. Use containment (`@>`), field access (`->` / `->>`), or the `eql_v3.jsonb_path_*` functions instead. +These native PostgreSQL JSONB operators are **blocked** on `public.eql_v3_json_search` (they `RAISE`, rather than falling through to native whole-document semantics): root-document `=` `<>` `<` `<=` `>` `>=`, and `?`, `?|`, `?&`, `@?`, `@@`, `#>`, `#>>`, `-`, `#-`, `||`. Use containment (`@>`), field access (`->` / `->>`), or the `eql_v3.jsonb_path_*` functions instead. See [EQL with JSON and JSONB](./json-support.md) for worked examples. @@ -162,7 +162,7 @@ See [EQL with JSON and JSONB](./json-support.md) for worked examples. - [EQL Functions Reference](./eql-functions.md) — full list of functions and operators. - [Database Indexes for Encrypted Columns](./database-indexes.md) — functional-index and GIN recipes, plus performance guidance. -- [EQL with JSON and JSONB](./json-support.md) — end-to-end `public.eql_v3_json` examples. +- [EQL with JSON and JSONB](./json-support.md) — end-to-end `public.eql_v3_json_search` examples. - Client-side searchable-encryption configuration — [CipherStash Stack schema reference](https://cipherstash.com/docs/stack/cipherstash/encryption/schema) and [CipherStash Proxy](https://github.com/cipherstash/proxy). --- diff --git a/docs/tutorials/proxy-configuration.md b/docs/tutorials/proxy-configuration.md index f5bce0de5..93f003916 100644 --- a/docs/tutorials/proxy-configuration.md +++ b/docs/tutorials/proxy-configuration.md @@ -8,7 +8,7 @@ EQL (the `eql_v3` schema) and the encryption client split responsibilities: | Responsibility | Owner | | --- | --- | -| Encrypted-column **types** and **operators** (`public.eql_v3_text_eq`, `public.eql_v3_json`, `=`, `@>`, …) | **EQL** (this repo) | +| Encrypted-column **types** and **operators** (`public.eql_v3_text_eq`, `public.eql_v3_json_search`, `=`, `@>`, …) | **EQL** (this repo) | | PostgreSQL **functional indexes** on the term extractors | **EQL** / you | | **Which columns are encrypted** and **which index terms** each carries | The **encryption client** — [CipherStash Proxy](https://github.com/cipherstash/proxy) / [CipherStash Stack](https://github.com/cipherstash/stack) | | Performing **encryption / decryption** on the wire | The encryption client | @@ -35,10 +35,10 @@ ALTER TABLE events ADD COLUMN encrypted_at public.eql_v3_timestamp_ord; ALTER TABLE users ADD COLUMN encrypted_name public.eql_v3_text_match; -- searchable encrypted JSON document -ALTER TABLE users ADD COLUMN encrypted_profile public.eql_v3_json; +ALTER TABLE users ADD COLUMN encrypted_profile public.eql_v3_json_search; ``` -The variant fixes the column's searchable surface: `_eq` for `=`, `_ord` for ordering/range, `text_match` for `@>` token containment, `public.eql_v3_json` for encrypted JSON. The bare `eql_v3.` variant is storage/decryption only. +The variant fixes the column's searchable surface: `_eq` for `=`, `_ord` for ordering/range, `text_match` for `@>` token containment, `public.eql_v3_json_search` for encrypted JSON. The bare `eql_v3.` variant is storage/decryption only. ## 2. Configure searchable encryption in the client @@ -99,10 +99,10 @@ SELECT * FROM events WHERE encrypted_at < $1 ORDER BY eql_v3.ord_term(encrypted_ SELECT * FROM users WHERE encrypted_name @> $1::public.eql_v3_text_match; ``` -**Encrypted JSON** (`public.eql_v3_json`) — containment and field access; see [EQL with JSON and JSONB](../reference/json-support.md): +**Encrypted JSON** (`public.eql_v3_json_search`) — containment and field access; see [EQL with JSON and JSONB](../reference/json-support.md): ```sql -SELECT * FROM users WHERE encrypted_profile @> $1::eql_v3.query_jsonb; +SELECT * FROM users WHERE encrypted_profile @> $1::eql_v3.query_json; SELECT encrypted_profile -> 'email_selector'::text FROM users; ``` @@ -114,11 +114,11 @@ SELECT encrypted_profile -> 'email_selector'::text FROM users; **Which operators are available on which column?** See the [SQL support matrix](../reference/sql-support.md). -**Where is the data format documented?** See the [payload / wire format](../../crates/eql-bindings/README.md) for the scalar envelope and index terms, and [EQL with JSON and JSONB](../reference/json-support.md) for the `public.eql_v3_json` document format. +**Where is the data format documented?** See the [payload / wire format](../../crates/eql-bindings/README.md) for the scalar envelope and index terms, and [EQL with JSON and JSONB](../reference/json-support.md) for the `public.eql_v3_json_search` document format. ## Troubleshooting -**Operator resolves to native `jsonb` / returns `NULL` instead of searching.** The query operand was an untyped literal, so PostgreSQL flattened the `eql_v3` domain to `jsonb`. Type the operand (`$1::public.eql_v3_text_eq`, `$1::eql_v3.query_jsonb`) — the Proxy does this automatically. +**Operator resolves to native `jsonb` / returns `NULL` instead of searching.** The query operand was an untyped literal, so PostgreSQL flattened the `eql_v3` domain to `jsonb`. Type the operand (`$1::public.eql_v3_text_eq`, `$1::eql_v3.query_json`) — the Proxy does this automatically. **`=` returns no rows.** The column's values do not carry an `hm` equality term. Confirm the client is configured to emit the right term for the column's variant (step 2), and that data was written through the Proxy after configuring it. diff --git a/docs/upgrading/v3.0.md b/docs/upgrading/v3.0.md index cbea9eb2c..839e98cf3 100644 --- a/docs/upgrading/v3.0.md +++ b/docs/upgrading/v3.0.md @@ -8,18 +8,19 @@ release is prepared. ## TL;DR 1. **The `eql_v3` JSON envelope version is now `v: 3`** ([U-001](#u-001-eql_v3-payloads-carry-v-3)). Every `eql_v3` domain `CHECK` pins `VALUE->>'v' = '3'`, and the published payload bindings (Rust / TypeScript / JSON Schema) accept exactly `3`. Payloads carrying the legacy `v: 2` are rejected on insert or cast. -2. **Query-operand domains are `eql_v3.query_`** ([U-002](#u-002-query-operand-domains-are-eql_v3query_name)). Renamed from the `_query` suffix to a `query_` prefix AND moved from `public` into the `eql_v3` schema: `public.integer_eq_query` → `eql_v3.query_integer_eq`, and the encrypted-JSONB containment needle `public.jsonb_query` → `eql_v3.query_jsonb`. Only affects 3.0.0 pre-release adopters — the old names never shipped in a final release. +2. **Query-operand domains are `eql_v3.query_`** ([U-002](#u-002-query-operand-domains-are-eql_v3query_name)). Renamed from the `_query` suffix to a `query_` prefix AND moved from `public` into the `eql_v3` schema: `public.integer_eq_query` → `eql_v3.query_integer_eq`, and the encrypted-JSONB containment needle `public.jsonb_query` → `eql_v3.query_json`. Only affects 3.0.0 pre-release adopters — the old names never shipped in a final release. 3. **Non-superuser installs disable the ORE-backed domains** ([U-003](#u-003-non-superuser-installs-disable-the-ore-backed-domains)). When the installer role cannot create the ORE operator class (cloud-hosted Supabase, most managed Postgres), the `_ord_ore` / `text_search_ore` domains and their query twins now raise `feature_not_supported` on first use instead of silently degrading to seq scans. Use `_ord` (indexed OPE ordering), `_eq`, and `text_match` on those platforms. Superuser installs are unchanged. 4. **SteVec (encrypted JSONB) ordering is CLLW-OPE: sv entries carry `hm` XOR `op`, not `hm` XOR `oc`** ([U-004](#u-004-stevec-ordering-terms-are-cllw-ope-op)). The `eql_v3_internal.ore_cllw` composite type, its custom comparator, operators, and superuser-only btree operator class are removed; entry ordering extracts `eql_v3.ord_term(entry)` — a bytea domain that orders under the DEFAULT btree opclass. `oc`-bearing documents are rejected by the v3 domain CHECKs and must be re-encrypted with an OPE-mode client. 5. **The `_ord` domains are backed by CLLW-OPE, not block-ORE** ([U-005](#u-005-_ord-domains-are-backed-by-cllw-ope)). `public._ord` and `public.eql_v3_text_ord` now require the `op` term. The extractor keeps its name — `eql_v3.ord_term(col)` — but now returns `eql_v3_internal.ope_cllw`, so ordered functional indexes no longer need a superuser-created operator class. The block-ORE surface moves behind the qualified `eql_v3.ord_term_ore(col)` on `public._ord_ore`. Two behaviour changes ride along: `text_ord` now accepts the empty string, and `real`/`double` `_ord` columns now distinguish `-0.0` from `+0.0`. 6. **`public.eql_v3_text_search` is backed by CLLW-OPE too, and `public.eql_v3_text_search_ore` is new** ([U-006](#u-006-text_search-is-backed-by-cllw-ope)). The combined search domain now requires `hm` + `op` + `bf` and orders via `eql_v3.ord_term(col)`; equality (`hm`) and bloom containment (`bf`) are unchanged. The block-ORE shape (`hm` + `ob` + `bf`) lives on the new `public.eql_v3_text_search_ore`. `text_search` now accepts the empty string. +7. **The encrypted-JSON domains are renamed, and `public.eql_v3_json` is now storage-only** ([U-007](#u-007-the-encrypted-json-domains-are-renamed-and-publiceql_v3_json-is-now-storage-only)). The searchable SteVec document `public.eql_v3_json` → `public.eql_v3_json_search`, `public.eql_v3_jsonb_entry` → `public.eql_v3_json_entry`, `eql_v3.query_jsonb` → `eql_v3.query_json`; the bare `public.eql_v3_json` is now a new ciphertext-only storage-only domain. Only affects 3.0.0 pre-release adopters. ## Compatibility | Component | Status | | --- | --- | | `eql_v3` schema name, column-domain names, operator names | **Unchanged.** | -| Query-operand domains (`public._query`, `public.jsonb_query` — 3.0.0 pre-releases only) | **Changed.** Now `eql_v3.query_` / `eql_v3.query_jsonb` — see U-002. | +| Query-operand domains (`public._query`, `public.jsonb_query` — 3.0.0 pre-releases only) | **Changed.** Now `eql_v3.query_` / `eql_v3.query_json` — see U-002. | | `eql_v3` payload envelope version (`v`) | **Changed.** `2` → `3`. Re-encryption / re-emission with a v3-envelope client required — see U-001. | | ORE-carrying domains (`_ord_ore` / `text_search_ore` + query twins) on non-superuser installs | **Changed.** Poisoned at install time — raise `feature_not_supported` on use instead of silently degrading — see U-003. Superuser installs unchanged. | | `public._ord`, `public.eql_v3_text_ord` ordering SEM | **Changed.** Block-ORE (`ob`) → CLLW-OPE (`op`). The extractor keeps the name `eql_v3.ord_term`, but its return type changes `eql_v3_internal.ore_block_256` → `eql_v3_internal.ope_cllw` — see U-005. | @@ -27,12 +28,13 @@ release is prepared. | `public.eql_v3_text_search` ordering SEM | **Changed.** Block-ORE (`ob`) → CLLW-OPE (`op`) — see U-006. | | `public.eql_v3_text_search_ore` | **New.** The block-ORE (`ob`) sibling of `text_search` — see U-006. | | `eql_v3.ord_term(public._ord_ore)` extractor | **Renamed** to `eql_v3.ord_term_ore` — the qualified name now belongs to block-ORE — see U-005. | -| `eql_v3.ord_ope_term` (3.0.0 pre-releases only) | **Removed.** Folded into `eql_v3.ord_term` — the scalar `_ord` / `_ord_ope` overloads and the SteVec `public.eql_v3_jsonb_entry` overload alike — see U-005. | +| `eql_v3.ord_ope_term` (3.0.0 pre-releases only) | **Removed.** Folded into `eql_v3.ord_term` — the scalar `_ord` / `_ord_ope` overloads and the SteVec `public.eql_v3_json_entry` overload alike — see U-005. | | `public._ord_ope` | **Unchanged.** Now a byte-identical twin of `_ord`; extracted with `eql_v3.ord_term`. | | `real` / `double` `_ord` signed-zero semantics | **Changed.** `-0.0` and `+0.0` are now distinct under `=` and `<` (block-ORE canonicalized them; CLLW-OPE does not) — see U-005. | | `text_ord` and the empty string | **Changed.** Now accepted and sorted first; previously a `check_violation` — see U-005. | | `eql_v3` payload term keys (`hm` / `ob` / `bf` / `op`) | **Unchanged** as keys; which key an `_ord` column requires changed — see U-005. | | SteVec sv-entry term keys | **Changed.** `hm` XOR `op` (CLLW-OPE); `oc` (CLLW-ORE) is rejected — see U-004. | +| Encrypted-JSON domains (`public.eql_v3_json` searchable, `public.eql_v3_jsonb_entry` — 3.0.0 pre-releases only) | **Renamed.** Searchable document → `public.eql_v3_json_search`, entry → `public.eql_v3_json_entry`; the bare `public.eql_v3_json` is now a new storage-only domain — see U-007. | | `eql_v3.ore_cllw(entry)` / `eql_v3.has_ore_cllw(entry)` / `eql_v3_internal.ore_cllw` (+ comparator, operators, opclass) | **Removed.** Entry ordering is `eql_v3.ord_term(entry)` — see U-004. | | Legacy `eql_v2` wire documentation (`docs/reference/schema/eql-payload-v2.*.schema.json`) | **Unchanged.** Stays `v: 2`. | @@ -43,7 +45,7 @@ release is prepared. **What changed.** The `eql_v3` tier previously reused the v2 wire's envelope version (`v: 2`) for continuity. With 3.0.0 the tier carries the envelope version matching its schema generation: every generated scalar domain `CHECK` -and the hand-written `public.eql_v3_json` SteVec document `CHECK` pin +and the hand-written `public.eql_v3_json_search` SteVec document `CHECK` pin `VALUE->>'v' = '3'`, and `eql-bindings`' `SchemaVersion` (with the emitted TypeScript alias and the JSON Schema `const`) accepts exactly `3`. @@ -76,13 +78,13 @@ client casts query parameters to — changed identity in two coordinated ways relative to the 3.0.0 pre-releases: 1. **Named with a `query_` PREFIX** instead of the `_query` suffix: - `query_integer_eq`, `query_text_ord`, …, and `query_jsonb` for the + `query_integer_eq`, `query_text_ord`, …, and `query_json` for the encrypted-JSONB containment needle (was `jsonb_query`). 2. **Moved from `public` into the `eql_v3` schema**: `eql_v3.query_integer_eq`, - `eql_v3.query_jsonb`, …. + `eql_v3.query_json`, …. The old names never shipped in a final release. The column-type domains -(`public.eql_v3_integer_eq`, `public.eql_v3_json`, `public.eql_v3_jsonb_entry`, …) are unchanged — +(`public.eql_v3_integer_eq`, `public.eql_v3_json_search`, `public.eql_v3_json_entry`, …) are unchanged — they stay in `public` so dropping EQL-owned schemas can never drop an application column. @@ -103,7 +105,7 @@ the `schema/v3/*_query.json` JSON Schema files). **What to do.** -- Rename the casts: `$1::eql_v3.query_integer_eq`, `$1::eql_v3.query_jsonb`. +- Rename the casts: `$1::eql_v3.query_integer_eq`, `$1::eql_v3.query_json`. - Update `eql-bindings` to the matching release (the `DomainType::sql_domain` strings, `QueryPayload::parse` names, and JSON Schema file names follow the new convention). @@ -123,7 +125,7 @@ the `schema/v3/*_query.json` JSON Schema files). ```sql -- Must succeed (the relocated operand domains exist): SELECT '{"v":3,"i":{},"hm":"aa"}'::jsonb::eql_v3.query_text_eq; -SELECT '{"sv":[{"s":"aa","hm":"bb"}]}'::jsonb::eql_v3.query_jsonb; +SELECT '{"sv":[{"s":"aa","hm":"bb"}]}'::jsonb::eql_v3.query_json; -- Must fail with "type does not exist" (the pre-release names are gone): SELECT '{"v":3,"i":{},"hm":"aa"}'::jsonb::public.text_eq_query; SELECT '{"v":3,"i":{},"hm":"aa"}'::jsonb::public.query_text_eq; @@ -200,11 +202,11 @@ that only a superuser install could create. Entries now carry `hm` XOR `op`, where `op` is a CLLW-*OPE* (Order-Preserving Encryption) ciphertext whose hex-decoded bytes order under **native bytea comparison** — the same `op` term and `eql_v3_internal.ope_cllw` bytea domain the scalar `_ord` / -`_ord_ope` domains use. The domain CHECKs on `public.eql_v3_json` / -`public.eql_v3_jsonb_entry` / `eql_v3.query_jsonb` validate `hm` XOR `op` and reject +`_ord_ope` domains use. The domain CHECKs on `public.eql_v3_json_search` / +`public.eql_v3_json_entry` / `eql_v3.query_json` validate `hm` XOR `op` and reject `oc`. The `eql_v3.ore_cllw(entry)` and `eql_v3.has_ore_cllw(entry)` functions and the entire `eql_v3_internal.ore_cllw` surface are removed; the entry -ordering extractor is the `public.eql_v3_jsonb_entry` overload of +ordering extractor is the `public.eql_v3_json_entry` overload of `eql_v3.ord_term` (SQL `NULL` when the entry carries no `op`). **Why.** `CREATE OPERATOR CLASS` requires superuser, so SteVec entry @@ -214,8 +216,8 @@ Supabase / managed Postgres. The OPE term needs no operator class at all — the whole comparison chain is inlinable SQL, and a plain functional btree index engages structurally on any install. -**Who is affected.** Every producer and consumer of `public.eql_v3_json` / -`public.eql_v3_jsonb_entry` payloads, and any SQL using the removed functions. +**Who is affected.** Every producer and consumer of `public.eql_v3_json_search` / +`public.eql_v3_json_entry` payloads, and any SQL using the removed functions. **What to do.** @@ -240,11 +242,11 @@ index engages structurally on any install. ```sql -- Must succeed (op-bearing entry): -SELECT '{"i":{},"v":3,"k":"sv","sv":[{"s":"aa","c":"ct","op":"01ff"}]}'::jsonb::public.eql_v3_json; +SELECT '{"i":{},"v":3,"k":"sv","sv":[{"s":"aa","c":"ct","op":"01ff"}]}'::jsonb::public.eql_v3_json_search; -- Must fail with a check_violation (oc is no longer a valid entry term): -SELECT '{"i":{},"v":3,"k":"sv","sv":[{"s":"aa","c":"ct","oc":"01ff"}]}'::jsonb::public.eql_v3_json; +SELECT '{"i":{},"v":3,"k":"sv","sv":[{"s":"aa","c":"ct","oc":"01ff"}]}'::jsonb::public.eql_v3_json_search; -- Must fail with "function does not exist": -SELECT eql_v3.ore_cllw(NULL::public.eql_v3_jsonb_entry); +SELECT eql_v3.ore_cllw(NULL::public.eql_v3_json_entry); ``` ### U-005: `_ord` domains are backed by CLLW-OPE @@ -502,3 +504,53 @@ SELECT '{"v":3,"i":{},"c":"x","hm":"aa","ob":["aa"],"bf":[1]}'::jsonb::public.eq **Rollback.** `ALTER TABLE … ALTER COLUMN … TYPE public.eql_v3_text_search_ore` and rebuild the ordered index against `eql_v3.ord_term_ore(col)`. The block-ORE surface is still installed, so no EQL downgrade is required. + +### U-007: the encrypted-JSON domains are renamed, and `public.eql_v3_json` is now storage-only + +**What changed.** The JSON family now follows the same naming convention as every +scalar family — the bare family name is the **storage-only** domain, and a suffix +marks the searchable variant. Three renames plus one new domain: + +| Before (3.0.0 pre-release) | After | What it is | +| --- | --- | --- | +| `public.eql_v3_json` | `public.eql_v3_json_search` | searchable SteVec document (`@>`, path access, ordered field compare) | +| `public.eql_v3_jsonb_entry` | `public.eql_v3_json_entry` | one `sv` element (returned by `->`) | +| `eql_v3.query_jsonb` | `eql_v3.query_json` | containment needle (query operand) | +| — (new) | `public.eql_v3_json` | ciphertext-only, storage-only encrypted JSON (`{v,i,c}`, no index terms) | + +The bare `public.eql_v3_json` name no longer means the searchable document — it is +now a storage-only domain (the JSON analogue of `public.eql_v3_boolean`): one +opaque ciphertext for encrypt-at-rest with no server-side searchability. Every +comparison/containment native jsonb operator (`=`, `@>`, `<@`, `#>`, `||`) is +blocked on it. + +**Why.** Consistency. For every scalar family the bare name is storage-only and a +suffix (`_eq`, `_ord`, `_search`) adds capability; the JSON family was the lone +exception, where the bare name was the fully-searchable document and there was no +storage-only form. `_search` mirrors text's combined `_search` domain, and the new +bare `public.eql_v3_json` fills the previously-missing ciphertext-only slot. + +**Who is affected.** Anyone with a column typed `public.eql_v3_json` (the searchable +document), a `public.eql_v3_jsonb_entry` reference, or a query cast to +`eql_v3.query_jsonb` — all from a 3.0.0 pre-release. The old names never shipped in +a final release. + +**What to do.** Retype searchable columns to `public.eql_v3_json_search` and update +containment casts to `eql_v3.query_json`: + +```sql +ALTER TABLE t ALTER COLUMN doc TYPE public.eql_v3_json_search; +-- containment queries: +SELECT * FROM t WHERE doc @> $1::eql_v3.query_json; +``` + +Use the new bare `public.eql_v3_json` only for encrypt-at-rest JSON you never search: + +```sql +-- storage-only: accepts the {v,i,c} envelope, rejects a SteVec document +SELECT '{"v":"3","i":{},"c":"x"}'::jsonb::public.eql_v3_json; -- ok +SELECT '{"v":"3","i":{},"sv":[{"s":"a","hm":"h"}]}'::jsonb::public.eql_v3_json; -- check_violation +``` + +**Rollback.** None required beyond retyping columns back — this is a rename of a +pre-release surface; no envelope or term-key change rides along. diff --git a/packages/eql/src/generated/schema-manifest.ts b/packages/eql/src/generated/schema-manifest.ts index 7ab116c18..cecca69ed 100644 --- a/packages/eql/src/generated/schema-manifest.ts +++ b/packages/eql/src/generated/schema-manifest.ts @@ -20,8 +20,9 @@ export const schemaNames = [ 'eql_v3_integer_ord_ore', 'eql_v3_integer_ord', 'eql_v3_integer', + 'eql_v3_json_entry', + 'eql_v3_json_search', 'eql_v3_json', - 'eql_v3_jsonb_entry', 'eql_v3_numeric_eq', 'eql_v3_numeric_ord_ope', 'eql_v3_numeric_ord_ore', @@ -66,7 +67,7 @@ export const schemaNames = [ 'query_integer_ord_ope', 'query_integer_ord_ore', 'query_integer_ord', - 'query_jsonb', + 'query_json', 'query_numeric_eq', 'query_numeric_ord_ope', 'query_numeric_ord_ore', @@ -114,8 +115,9 @@ export const schemaIds = { "eql_v3_integer_ord_ore": "https://schemas.cipherstash.com/eql/v3/eql_v3_integer_ord_ore.json", "eql_v3_integer_ord": "https://schemas.cipherstash.com/eql/v3/eql_v3_integer_ord.json", "eql_v3_integer": "https://schemas.cipherstash.com/eql/v3/eql_v3_integer.json", + "eql_v3_json_entry": "https://schemas.cipherstash.com/eql/v3/eql_v3_json_entry.json", + "eql_v3_json_search": "https://schemas.cipherstash.com/eql/v3/eql_v3_json_search.json", "eql_v3_json": "https://schemas.cipherstash.com/eql/v3/eql_v3_json.json", - "eql_v3_jsonb_entry": "https://schemas.cipherstash.com/eql/v3/eql_v3_jsonb_entry.json", "eql_v3_numeric_eq": "https://schemas.cipherstash.com/eql/v3/eql_v3_numeric_eq.json", "eql_v3_numeric_ord_ope": "https://schemas.cipherstash.com/eql/v3/eql_v3_numeric_ord_ope.json", "eql_v3_numeric_ord_ore": "https://schemas.cipherstash.com/eql/v3/eql_v3_numeric_ord_ore.json", @@ -160,7 +162,7 @@ export const schemaIds = { "query_integer_ord_ope": "https://schemas.cipherstash.com/eql/v3/query_integer_ord_ope.json", "query_integer_ord_ore": "https://schemas.cipherstash.com/eql/v3/query_integer_ord_ore.json", "query_integer_ord": "https://schemas.cipherstash.com/eql/v3/query_integer_ord.json", - "query_jsonb": "https://schemas.cipherstash.com/eql/v3/query_jsonb.json", + "query_json": "https://schemas.cipherstash.com/eql/v3/query_json.json", "query_numeric_eq": "https://schemas.cipherstash.com/eql/v3/query_numeric_eq.json", "query_numeric_ord_ope": "https://schemas.cipherstash.com/eql/v3/query_numeric_ord_ope.json", "query_numeric_ord_ore": "https://schemas.cipherstash.com/eql/v3/query_numeric_ord_ore.json", diff --git a/packages/eql/src/generated/schema/v3/eql_v3_json.json b/packages/eql/src/generated/schema/v3/eql_v3_json.json index 048152251..5a206f9d9 100644 --- a/packages/eql/src/generated/schema/v3/eql_v3_json.json +++ b/packages/eql/src/generated/schema/v3/eql_v3_json.json @@ -4,10 +4,6 @@ "description": "mp_base85 source ciphertext — the `c` envelope key.\n\nRequired by every v3 domain CHECK; present on every payload.", "type": "string" }, - "Hmac256": { - "description": "HMAC-SHA-256 equality term — the `hm` wire key. Backs the `_eq` domains\n(`=`, `<>`). SQL-side constructor: `eql_v3_internal.hmac_256`.", - "type": "string" - }, "Identifier": { "additionalProperties": false, "description": "Table + column identifier — wire shape `{\"t\": \"...\", \"c\": \"...\"}`.\n\nShared by every payload.", @@ -27,98 +23,32 @@ ], "type": "object" }, - "OpeCllw": { - "description": "CLLW-OPE order term — the `op` wire key. Backs the scalar `_ord` (the\ndefault ordering domain), `_ord_ope`, and `text_search` domains, their\n`query_` operands (`=` `<>` `<` `<=` `>` `>=`), and the ordered entries\nof a SteVec document (exactly one of `hm` (equality) XOR `op` (ordering)\nper entry — enforced by the SQL domain CHECK): a hex-encoded CLLW OPE\nciphertext, sortable via native bytea comparison after hex-decode —\nunlike `ob` (block-ORE) it needs no custom comparator. Extracted by\n`eql_v3.ord_term` (scalar domains and the `public.jsonb_entry` overload\nalike); SQL-side constructor: `eql_v3_internal.ope_cllw`.", - "type": "string" - }, "SchemaVersion": { "const": 3, "description": "The envelope version field (`v`) — always exactly `3` on the wire.", "type": "integer" - }, - "Selector": { - "description": "A SteVec selector — the `s` wire key. Addresses a JSON path leaf within an\nencrypted document (`public.eql_v3_json`); present on every entry and query element.", - "type": "string" - }, - "SteVecEntry": { - "anyOf": [ - { - "properties": { - "hm": { - "$ref": "#/$defs/Hmac256" - } - }, - "required": [ - "hm" - ], - "type": "object" - }, - { - "properties": { - "op": { - "$ref": "#/$defs/OpeCllw" - } - }, - "required": [ - "op" - ], - "type": "object" - } - ], - "description": "`public.eql_v3_jsonb_entry` — one sv element (returned by `->`). Carries a selector\n`s`, ciphertext `c`, optional array-membership marker `a`, and exactly one of\n`hm` XOR `op`. LAX (flatten precludes `deny_unknown_fields`): tolerates the\nroot `i`/`v` merged in by `->`. XOR of the term is enforced by the SQL CHECK.", - "properties": { - "a": { - "type": [ - "boolean", - "null" - ] - }, - "c": { - "$ref": "#/$defs/Ciphertext" - }, - "s": { - "$ref": "#/$defs/Selector" - } - }, - "required": [ - "s", - "c" - ], - "type": "object" - }, - "SteVecForm": { - "const": "sv", - "description": "The `k` envelope form discriminator — always `\"sv\"` for a SteVec document.", - "type": "string" } }, "$id": "https://schemas.cipherstash.com/eql/v3/eql_v3_json.json", "$schema": "https://json-schema.org/draft/2020-12/schema", "additionalProperties": false, - "description": "`public.eql_v3_json` — a SteVec encrypted-JSONB document (`{v, k, i, sv:[entry]}`,\nno root ciphertext). Strict. `k` is the `\"sv\"` form discriminator (see\n[`SteVecForm`]) — carried on the real wire, so the strict struct models it.", + "description": "`public.eql_v3_json` — storage-only domain.\n\nOperators: none. Required keys: `v` `i` `c`.", "properties": { + "c": { + "$ref": "#/$defs/Ciphertext" + }, "i": { "$ref": "#/$defs/Identifier" }, - "k": { - "$ref": "#/$defs/SteVecForm" - }, - "sv": { - "items": { - "$ref": "#/$defs/SteVecEntry" - }, - "type": "array" - }, "v": { "$ref": "#/$defs/SchemaVersion" } }, "required": [ "v", - "k", "i", - "sv" + "c" ], - "title": "SteVecDocument", + "title": "Json", "type": "object" } \ No newline at end of file diff --git a/packages/eql/src/generated/schema/v3/eql_v3_jsonb_entry.json b/packages/eql/src/generated/schema/v3/eql_v3_json_entry.json similarity index 80% rename from packages/eql/src/generated/schema/v3/eql_v3_jsonb_entry.json rename to packages/eql/src/generated/schema/v3/eql_v3_json_entry.json index 5a593c34c..ca28a3cbe 100644 --- a/packages/eql/src/generated/schema/v3/eql_v3_jsonb_entry.json +++ b/packages/eql/src/generated/schema/v3/eql_v3_json_entry.json @@ -13,11 +13,11 @@ "type": "string" }, "Selector": { - "description": "A SteVec selector — the `s` wire key. Addresses a JSON path leaf within an\nencrypted document (`public.eql_v3_json`); present on every entry and query element.", + "description": "A SteVec selector — the `s` wire key. Addresses a JSON path leaf within an\nencrypted document (`public.eql_v3_json_search`); present on every entry and query element.", "type": "string" } }, - "$id": "https://schemas.cipherstash.com/eql/v3/eql_v3_jsonb_entry.json", + "$id": "https://schemas.cipherstash.com/eql/v3/eql_v3_json_entry.json", "$schema": "https://json-schema.org/draft/2020-12/schema", "anyOf": [ { @@ -43,7 +43,7 @@ "type": "object" } ], - "description": "`public.eql_v3_jsonb_entry` — one sv element (returned by `->`). Carries a selector\n`s`, ciphertext `c`, optional array-membership marker `a`, and exactly one of\n`hm` XOR `op`. LAX (flatten precludes `deny_unknown_fields`): tolerates the\nroot `i`/`v` merged in by `->`. XOR of the term is enforced by the SQL CHECK.", + "description": "`public.eql_v3_json_entry` — one sv element (returned by `->`). Carries a selector\n`s`, ciphertext `c`, optional array-membership marker `a`, and exactly one of\n`hm` XOR `op`. LAX (flatten precludes `deny_unknown_fields`): tolerates the\nroot `i`/`v` merged in by `->`. XOR of the term is enforced by the SQL CHECK.", "properties": { "a": { "type": [ diff --git a/packages/eql/src/generated/schema/v3/eql_v3_json_search.json b/packages/eql/src/generated/schema/v3/eql_v3_json_search.json new file mode 100644 index 000000000..9aafe9a01 --- /dev/null +++ b/packages/eql/src/generated/schema/v3/eql_v3_json_search.json @@ -0,0 +1,124 @@ +{ + "$defs": { + "Ciphertext": { + "description": "mp_base85 source ciphertext — the `c` envelope key.\n\nRequired by every v3 domain CHECK; present on every payload.", + "type": "string" + }, + "Hmac256": { + "description": "HMAC-SHA-256 equality term — the `hm` wire key. Backs the `_eq` domains\n(`=`, `<>`). SQL-side constructor: `eql_v3_internal.hmac_256`.", + "type": "string" + }, + "Identifier": { + "additionalProperties": false, + "description": "Table + column identifier — wire shape `{\"t\": \"...\", \"c\": \"...\"}`.\n\nShared by every payload.", + "properties": { + "c": { + "description": "Column name.", + "type": "string" + }, + "t": { + "description": "Table name.", + "type": "string" + } + }, + "required": [ + "t", + "c" + ], + "type": "object" + }, + "OpeCllw": { + "description": "CLLW-OPE order term — the `op` wire key. Backs the scalar `_ord` (the\ndefault ordering domain), `_ord_ope`, and `text_search` domains, their\n`query_` operands (`=` `<>` `<` `<=` `>` `>=`), and the ordered entries\nof a SteVec document (exactly one of `hm` (equality) XOR `op` (ordering)\nper entry — enforced by the SQL domain CHECK): a hex-encoded CLLW OPE\nciphertext, sortable via native bytea comparison after hex-decode —\nunlike `ob` (block-ORE) it needs no custom comparator. Extracted by\n`eql_v3.ord_term` (scalar domains and the `public.jsonb_entry` overload\nalike); SQL-side constructor: `eql_v3_internal.ope_cllw`.", + "type": "string" + }, + "SchemaVersion": { + "const": 3, + "description": "The envelope version field (`v`) — always exactly `3` on the wire.", + "type": "integer" + }, + "Selector": { + "description": "A SteVec selector — the `s` wire key. Addresses a JSON path leaf within an\nencrypted document (`public.eql_v3_json_search`); present on every entry and query element.", + "type": "string" + }, + "SteVecEntry": { + "anyOf": [ + { + "properties": { + "hm": { + "$ref": "#/$defs/Hmac256" + } + }, + "required": [ + "hm" + ], + "type": "object" + }, + { + "properties": { + "op": { + "$ref": "#/$defs/OpeCllw" + } + }, + "required": [ + "op" + ], + "type": "object" + } + ], + "description": "`public.eql_v3_json_entry` — one sv element (returned by `->`). Carries a selector\n`s`, ciphertext `c`, optional array-membership marker `a`, and exactly one of\n`hm` XOR `op`. LAX (flatten precludes `deny_unknown_fields`): tolerates the\nroot `i`/`v` merged in by `->`. XOR of the term is enforced by the SQL CHECK.", + "properties": { + "a": { + "type": [ + "boolean", + "null" + ] + }, + "c": { + "$ref": "#/$defs/Ciphertext" + }, + "s": { + "$ref": "#/$defs/Selector" + } + }, + "required": [ + "s", + "c" + ], + "type": "object" + }, + "SteVecForm": { + "const": "sv", + "description": "The `k` envelope form discriminator — always `\"sv\"` for a SteVec document.", + "type": "string" + } + }, + "$id": "https://schemas.cipherstash.com/eql/v3/eql_v3_json_search.json", + "$schema": "https://json-schema.org/draft/2020-12/schema", + "additionalProperties": false, + "description": "`public.eql_v3_json_search` — a SteVec encrypted-JSON document (`{v, k, i, sv:[entry]}`,\nno root ciphertext). Strict. `k` is the `\"sv\"` form discriminator (see\n[`SteVecForm`]) — carried on the real wire, so the strict struct models it.", + "properties": { + "i": { + "$ref": "#/$defs/Identifier" + }, + "k": { + "$ref": "#/$defs/SteVecForm" + }, + "sv": { + "items": { + "$ref": "#/$defs/SteVecEntry" + }, + "type": "array" + }, + "v": { + "$ref": "#/$defs/SchemaVersion" + } + }, + "required": [ + "v", + "k", + "i", + "sv" + ], + "title": "SteVecDocument", + "type": "object" +} \ No newline at end of file diff --git a/packages/eql/src/generated/schema/v3/query_jsonb.json b/packages/eql/src/generated/schema/v3/query_json.json similarity index 90% rename from packages/eql/src/generated/schema/v3/query_jsonb.json rename to packages/eql/src/generated/schema/v3/query_json.json index ee72912b6..32e468b90 100644 --- a/packages/eql/src/generated/schema/v3/query_jsonb.json +++ b/packages/eql/src/generated/schema/v3/query_json.json @@ -9,7 +9,7 @@ "type": "string" }, "Selector": { - "description": "A SteVec selector — the `s` wire key. Addresses a JSON path leaf within an\nencrypted document (`public.eql_v3_json`); present on every entry and query element.", + "description": "A SteVec selector — the `s` wire key. Addresses a JSON path leaf within an\nencrypted document (`public.eql_v3_json_search`); present on every entry and query element.", "type": "string" }, "SteVecQueryEntry": { @@ -49,10 +49,10 @@ "type": "object" } }, - "$id": "https://schemas.cipherstash.com/eql/v3/query_jsonb.json", + "$id": "https://schemas.cipherstash.com/eql/v3/query_json.json", "$schema": "https://json-schema.org/draft/2020-12/schema", "additionalProperties": false, - "description": "`eql_v3.query_jsonb` — a containment needle (`{sv:[query-entry]}`). Strict.", + "description": "`eql_v3.query_json` — a containment needle (`{sv:[query-entry]}`). Strict.", "properties": { "sv": { "items": { diff --git a/packages/eql/src/generated/v3/Json.ts b/packages/eql/src/generated/v3/Json.ts new file mode 100644 index 000000000..7690666ff --- /dev/null +++ b/packages/eql/src/generated/v3/Json.ts @@ -0,0 +1,11 @@ +// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually. +import type { Ciphertext } from "./Ciphertext"; +import type { Identifier } from "./Identifier"; +import type { SchemaVersion } from "./SchemaVersion"; + +/** + * `public.eql_v3_json` — storage-only domain. + * + * Operators: none. Required keys: `v` `i` `c`. + */ +export type Json = { v: SchemaVersion, i: Identifier, c: Ciphertext, }; diff --git a/packages/eql/src/generated/v3/Selector.ts b/packages/eql/src/generated/v3/Selector.ts index deb18a4da..c380e1e75 100644 --- a/packages/eql/src/generated/v3/Selector.ts +++ b/packages/eql/src/generated/v3/Selector.ts @@ -2,6 +2,6 @@ /** * A SteVec selector — the `s` wire key. Addresses a JSON path leaf within an - * encrypted document (`public.eql_v3_json`); present on every entry and query element. + * encrypted document (`public.eql_v3_json_search`); present on every entry and query element. */ export type Selector = string; diff --git a/packages/eql/src/generated/v3/SteVecDocument.ts b/packages/eql/src/generated/v3/SteVecDocument.ts index 59b432b26..8c3643641 100644 --- a/packages/eql/src/generated/v3/SteVecDocument.ts +++ b/packages/eql/src/generated/v3/SteVecDocument.ts @@ -5,7 +5,7 @@ import type { SteVecEntry } from "./SteVecEntry"; import type { SteVecForm } from "./SteVecForm"; /** - * `public.eql_v3_json` — a SteVec encrypted-JSONB document (`{v, k, i, sv:[entry]}`, + * `public.eql_v3_json_search` — a SteVec encrypted-JSON document (`{v, k, i, sv:[entry]}`, * no root ciphertext). Strict. `k` is the `"sv"` form discriminator (see * [`SteVecForm`]) — carried on the real wire, so the strict struct models it. */ diff --git a/packages/eql/src/generated/v3/SteVecEntry.ts b/packages/eql/src/generated/v3/SteVecEntry.ts index 78f3cd9da..ba2429b80 100644 --- a/packages/eql/src/generated/v3/SteVecEntry.ts +++ b/packages/eql/src/generated/v3/SteVecEntry.ts @@ -5,7 +5,7 @@ import type { OpeCllw } from "./OpeCllw"; import type { Selector } from "./Selector"; /** - * `public.eql_v3_jsonb_entry` — one sv element (returned by `->`). Carries a selector + * `public.eql_v3_json_entry` — one sv element (returned by `->`). Carries a selector * `s`, ciphertext `c`, optional array-membership marker `a`, and exactly one of * `hm` XOR `op`. LAX (flatten precludes `deny_unknown_fields`): tolerates the * root `i`/`v` merged in by `->`. XOR of the term is enforced by the SQL CHECK. diff --git a/packages/eql/src/generated/v3/SteVecQuery.ts b/packages/eql/src/generated/v3/SteVecQuery.ts index eb1cab954..6ea0225d7 100644 --- a/packages/eql/src/generated/v3/SteVecQuery.ts +++ b/packages/eql/src/generated/v3/SteVecQuery.ts @@ -2,6 +2,6 @@ import type { SteVecQueryEntry } from "./SteVecQueryEntry"; /** - * `eql_v3.query_jsonb` — a containment needle (`{sv:[query-entry]}`). Strict. + * `eql_v3.query_json` — a containment needle (`{sv:[query-entry]}`). Strict. */ export type SteVecQuery = { sv: Array, }; diff --git a/packages/eql/src/generated/v3/index.ts b/packages/eql/src/generated/v3/index.ts index 1ba46f80b..06dca039e 100644 --- a/packages/eql/src/generated/v3/index.ts +++ b/packages/eql/src/generated/v3/index.ts @@ -39,6 +39,7 @@ export type * from './IntegerOrdOpeQuery' export type * from './IntegerOrdOre' export type * from './IntegerOrdOreQuery' export type * from './IntegerOrdQuery' +export type * from './Json' export type * from './Numeric' export type * from './NumericEq' export type * from './NumericEqQuery' diff --git a/src/v3/jsonb/aggregates.sql b/src/v3/json/aggregates.sql similarity index 71% rename from src/v3/jsonb/aggregates.sql rename to src/v3/json/aggregates.sql index 0b0cf9768..1d4d9ad86 100644 --- a/src/v3/jsonb/aggregates.sql +++ b/src/v3/json/aggregates.sql @@ -1,9 +1,9 @@ --- REQUIRE: src/v3/jsonb/types.sql --- REQUIRE: src/v3/jsonb/functions.sql +-- REQUIRE: src/v3/json/types.sql +-- REQUIRE: src/v3/json/functions.sql -- REQUIRE: src/v3/sem/ope_cllw/types.sql ---! @file v3/jsonb/aggregates.sql ---! @brief min / max aggregates over public.eql_v3_jsonb_entry. +--! @file v3/json/aggregates.sql +--! @brief min / max aggregates over public.eql_v3_json_entry. --! --! SteVec document entries extracted at a selector (`doc -> 'sel'`) order by --! their CLLW OPE (`op`) term, so the extremum is picked by comparing @@ -29,20 +29,20 @@ --! row is `op`-less. An all-`op`-less input has no orderable extremum and --! returns the (arbitrary) STRICT seed. ---! @brief State function for min on public.eql_v3_jsonb_entry. +--! @brief State function for min on public.eql_v3_json_entry. --! --! Keeps whichever orderable entry has the lesser CLLW OPE term. STRICT, so SQL --! NULL entries are skipped by the aggregate machinery; `op`-less (non-orderable) --! entries are skipped explicitly (see the @note on this file). --! ---! @param state public.eql_v3_jsonb_entry Running extremum. ---! @param value public.eql_v3_jsonb_entry Candidate entry. ---! @return public.eql_v3_jsonb_entry The lesser orderable entry by `ord_term`. +--! @param state public.eql_v3_json_entry Running extremum. +--! @param value public.eql_v3_json_entry Candidate entry. +--! @return public.eql_v3_json_entry The lesser orderable entry by `ord_term`. CREATE FUNCTION eql_v3_internal.jsonb_entry_min_sfunc( - state public.eql_v3_jsonb_entry, - value public.eql_v3_jsonb_entry + state public.eql_v3_json_entry, + value public.eql_v3_json_entry ) -RETURNS public.eql_v3_jsonb_entry +RETURNS public.eql_v3_json_entry LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -63,29 +63,29 @@ BEGIN END; $$; ---! @brief min aggregate over public.eql_v3_jsonb_entry. ---! @param input public.eql_v3_jsonb_entry ---! @return public.eql_v3_jsonb_entry The entry with the smallest CLLW OPE term. -CREATE AGGREGATE eql_v3.min(public.eql_v3_jsonb_entry) ( +--! @brief min aggregate over public.eql_v3_json_entry. +--! @param input public.eql_v3_json_entry +--! @return public.eql_v3_json_entry The entry with the smallest CLLW OPE term. +CREATE AGGREGATE eql_v3.min(public.eql_v3_json_entry) ( sfunc = eql_v3_internal.jsonb_entry_min_sfunc, - stype = public.eql_v3_jsonb_entry, + stype = public.eql_v3_json_entry, combinefunc = eql_v3_internal.jsonb_entry_min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_jsonb_entry. +--! @brief State function for max on public.eql_v3_json_entry. --! --! Keeps whichever orderable entry has the greater CLLW OPE term. `op`-less --! entries are skipped, mirroring `jsonb_entry_min_sfunc` (see the file @note). --! ---! @param state public.eql_v3_jsonb_entry Running extremum. ---! @param value public.eql_v3_jsonb_entry Candidate entry. ---! @return public.eql_v3_jsonb_entry The greater orderable entry by `ord_term`. +--! @param state public.eql_v3_json_entry Running extremum. +--! @param value public.eql_v3_json_entry Candidate entry. +--! @return public.eql_v3_json_entry The greater orderable entry by `ord_term`. CREATE FUNCTION eql_v3_internal.jsonb_entry_max_sfunc( - state public.eql_v3_jsonb_entry, - value public.eql_v3_jsonb_entry + state public.eql_v3_json_entry, + value public.eql_v3_json_entry ) -RETURNS public.eql_v3_jsonb_entry +RETURNS public.eql_v3_json_entry LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -106,12 +106,12 @@ BEGIN END; $$; ---! @brief max aggregate over public.eql_v3_jsonb_entry. ---! @param input public.eql_v3_jsonb_entry ---! @return public.eql_v3_jsonb_entry The entry with the largest CLLW OPE term. -CREATE AGGREGATE eql_v3.max(public.eql_v3_jsonb_entry) ( +--! @brief max aggregate over public.eql_v3_json_entry. +--! @param input public.eql_v3_json_entry +--! @return public.eql_v3_json_entry The entry with the largest CLLW OPE term. +CREATE AGGREGATE eql_v3.max(public.eql_v3_json_entry) ( sfunc = eql_v3_internal.jsonb_entry_max_sfunc, - stype = public.eql_v3_jsonb_entry, + stype = public.eql_v3_json_entry, combinefunc = eql_v3_internal.jsonb_entry_max_sfunc, parallel = safe ); diff --git a/src/v3/jsonb/blockers.sql b/src/v3/json/blockers.sql similarity index 72% rename from src/v3/jsonb/blockers.sql rename to src/v3/json/blockers.sql index 4344dcfb1..037019d89 100644 --- a/src/v3/jsonb/blockers.sql +++ b/src/v3/json/blockers.sql @@ -1,12 +1,12 @@ -- REQUIRE: src/v3/schema.sql --- REQUIRE: src/v3/jsonb/types.sql +-- REQUIRE: src/v3/json/types.sql -- REQUIRE: src/v3/scalars/functions.sql ---! @file v3/jsonb/blockers.sql ---! @brief Native-jsonb firewall for public.eql_v3_json. +--! @file v3/json/blockers.sql +--! @brief Native-jsonb firewall for public.eql_v3_json_search. --! ---! public.eql_v3_json SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons ---! = <> < <= > >= are supported on public.eql_v3_jsonb_entry only, not on the root +--! public.eql_v3_json_search SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons +--! = <> < <= > >= are supported on public.eql_v3_json_entry only, not on the root --! document domain. --! Every OTHER native jsonb operator reachable via domain fallback against the --! base type jsonb is BLOCKED here so an encrypted column can never silently @@ -24,417 +24,417 @@ --! so the firewall fires. --! @brief Blocker: ? (key/element exists). ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b text Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists(a public.eql_v3_json, b text) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists(a public.eql_v3_json_search, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '?'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR ? ( FUNCTION = eql_v3_internal.jsonb_blocked_exists, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = text ); --! @brief Blocker: ?| (any key exists). ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b text[] Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_any(a public.eql_v3_json, b text[]) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_any(a public.eql_v3_json_search, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '?|'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?|'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal.jsonb_blocked_exists_any, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = text[] ); --! @brief Blocker: ?& (all keys exist). ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b text[] Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_all(a public.eql_v3_json, b text[]) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_all(a public.eql_v3_json_search, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '?&'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?&'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal.jsonb_blocked_exists_all, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = text[] ); --! @brief Blocker: @? (jsonpath exists). ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b jsonpath Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_exists(a public.eql_v3_json, b jsonpath) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_exists(a public.eql_v3_json_search, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '@?'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@?'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR @? ( FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_exists, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = jsonpath ); --! @brief Blocker: @@ (jsonpath predicate). ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b jsonpath Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_match(a public.eql_v3_json, b jsonpath) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_match(a public.eql_v3_json_search, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '@@'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@@'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_match, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = jsonpath ); --! @brief Blocker: #> (path extract, native returns jsonb). ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b text[] Native RHS operand. --! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract(a public.eql_v3_json, b text[]) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract(a public.eql_v3_json_search, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '#>'); + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '#>'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR #> ( FUNCTION = eql_v3_internal.jsonb_blocked_path_extract, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = text[] ); --! @brief Blocker: #>> (path extract as text). ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b text[] Native RHS operand. --! @return text Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract_text(a public.eql_v3_json, b text[]) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract_text(a public.eql_v3_json_search, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_text('public.eql_v3_json', '#>>'); + RETURN eql_v3_internal.encrypted_domain_unsupported_text('public.eql_v3_json_search', '#>>'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal.jsonb_blocked_path_extract_text, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = text[] ); --! @brief Blocker: - (delete key, text RHS; native returns jsonb). ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b text Native RHS operand. --! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_text(a public.eql_v3_json, b text) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_text(a public.eql_v3_json_search, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '-'); + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR - ( FUNCTION = eql_v3_internal.jsonb_blocked_delete_text, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = text ); --! @brief Blocker: - (delete index, integer RHS). ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b integer Native RHS operand. --! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_int(a public.eql_v3_json, b integer) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_int(a public.eql_v3_json_search, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '-'); + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR - ( FUNCTION = eql_v3_internal.jsonb_blocked_delete_int, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = integer ); --! @brief Blocker: - (delete keys, text[] RHS). ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b text[] Native RHS operand. --! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_array(a public.eql_v3_json, b text[]) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_array(a public.eql_v3_json_search, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '-'); + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR - ( FUNCTION = eql_v3_internal.jsonb_blocked_delete_array, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = text[] ); --! @brief Blocker: #- (delete at path). ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b text[] Native RHS operand. --! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_path(a public.eql_v3_json, b text[]) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_path(a public.eql_v3_json_search, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '#-'); + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '#-'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR #- ( FUNCTION = eql_v3_internal.jsonb_blocked_delete_path, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = text[] ); --! @brief Blocker: || (concatenate, encrypted on the left). ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b jsonb Native RHS operand. --! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_concat(a public.eql_v3_json, b jsonb) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_concat(a public.eql_v3_json_search, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '||'); + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '||'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR || ( FUNCTION = eql_v3_internal.jsonb_blocked_concat, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = jsonb ); --! @brief Blocker: || (concatenate, encrypted on the right). --! @param a jsonb Native LHS operand. ---! @param b public.eql_v3_json Right operand (encrypted payload). +--! @param b public.eql_v3_json_search Right operand (encrypted payload). --! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_concat_rhs(a jsonb, b public.eql_v3_json) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_concat_rhs(a jsonb, b public.eql_v3_json_search) RETURNS jsonb IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '||'); + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '||'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR || ( FUNCTION = eql_v3_internal.jsonb_blocked_concat_rhs, LEFTARG = jsonb, - RIGHTARG = public.eql_v3_json + RIGHTARG = public.eql_v3_json_search ); ------------------------------------------------------------------------------ -- Root-document comparison blockers. ------------------------------------------------------------------------------ ---! @brief Blocker: root public.eql_v3_json document comparisons. ---! @param a public.eql_v3_json Left operand (encrypted payload). ---! @param b public.eql_v3_json Right operand (encrypted payload). +--! @brief Blocker: root public.eql_v3_json_search document comparisons. +--! @param a public.eql_v3_json_search Left operand (encrypted payload). +--! @param b public.eql_v3_json_search Right operand (encrypted payload). --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_json(a public.eql_v3_json, b public.eql_v3_json) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_json(a public.eql_v3_json_search, b public.eql_v3_json_search) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', 'comparison'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison'); END; $$ LANGUAGE plpgsql; ---! @brief Blocker: root public.eql_v3_json-to-jsonb comparisons. ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @brief Blocker: root public.eql_v3_json_search-to-jsonb comparisons. +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b jsonb Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_jsonb(a public.eql_v3_json, b jsonb) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_jsonb(a public.eql_v3_json_search, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', 'comparison'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison'); END; $$ LANGUAGE plpgsql; ---! @brief Blocker: root jsonb-to-public.eql_v3_json comparisons. +--! @brief Blocker: root jsonb-to-public.eql_v3_json_search comparisons. --! @param a jsonb Native LHS operand. ---! @param b public.eql_v3_json Right operand (encrypted payload). +--! @param b public.eql_v3_json_search Right operand (encrypted payload). --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_jsonb_json(a jsonb, b public.eql_v3_json) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_jsonb_json(a jsonb, b public.eql_v3_json_search) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', 'comparison'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR = ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = public.eql_v3_json, - RIGHTARG = public.eql_v3_json + LEFTARG = public.eql_v3_json_search, + RIGHTARG = public.eql_v3_json_search ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = jsonb ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, LEFTARG = jsonb, - RIGHTARG = public.eql_v3_json + RIGHTARG = public.eql_v3_json_search ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = public.eql_v3_json, - RIGHTARG = public.eql_v3_json + LEFTARG = public.eql_v3_json_search, + RIGHTARG = public.eql_v3_json_search ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = jsonb ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, LEFTARG = jsonb, - RIGHTARG = public.eql_v3_json + RIGHTARG = public.eql_v3_json_search ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = public.eql_v3_json, - RIGHTARG = public.eql_v3_json + LEFTARG = public.eql_v3_json_search, + RIGHTARG = public.eql_v3_json_search ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, LEFTARG = jsonb, - RIGHTARG = public.eql_v3_json + RIGHTARG = public.eql_v3_json_search ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = public.eql_v3_json, - RIGHTARG = public.eql_v3_json + LEFTARG = public.eql_v3_json_search, + RIGHTARG = public.eql_v3_json_search ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, LEFTARG = jsonb, - RIGHTARG = public.eql_v3_json + RIGHTARG = public.eql_v3_json_search ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = public.eql_v3_json, - RIGHTARG = public.eql_v3_json + LEFTARG = public.eql_v3_json_search, + RIGHTARG = public.eql_v3_json_search ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, LEFTARG = jsonb, - RIGHTARG = public.eql_v3_json + RIGHTARG = public.eql_v3_json_search ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = public.eql_v3_json, - RIGHTARG = public.eql_v3_json + LEFTARG = public.eql_v3_json_search, + RIGHTARG = public.eql_v3_json_search ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, LEFTARG = jsonb, - RIGHTARG = public.eql_v3_json + RIGHTARG = public.eql_v3_json_search ); ------------------------------------------------------------------------------ @@ -442,81 +442,81 @@ CREATE OPERATOR >= ( ------------------------------------------------------------------------------ --! @brief Blocker: @> with encrypted root document and native jsonb. ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b jsonb Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_json_jsonb(a public.eql_v3_json, b jsonb) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_json_jsonb(a public.eql_v3_json_search, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '@>'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@>'); END; $$ LANGUAGE plpgsql; --! @brief Blocker: @> with native jsonb and encrypted root document. --! @param a jsonb Native LHS operand. ---! @param b public.eql_v3_json Right operand (encrypted payload). +--! @param b public.eql_v3_json_search Right operand (encrypted payload). --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_jsonb_json(a jsonb, b public.eql_v3_json) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_jsonb_json(a jsonb, b public.eql_v3_json_search) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '@>'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@>'); END; $$ LANGUAGE plpgsql; --! @brief Blocker: <@ with encrypted root document and native jsonb. ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b jsonb Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_json_jsonb(a public.eql_v3_json, b jsonb) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_json_jsonb(a public.eql_v3_json_search, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '<@'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '<@'); END; $$ LANGUAGE plpgsql; --! @brief Blocker: <@ with native jsonb and encrypted root document. --! @param a jsonb Native LHS operand. ---! @param b public.eql_v3_json Right operand (encrypted payload). +--! @param b public.eql_v3_json_search Right operand (encrypted payload). --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_jsonb_json(a jsonb, b public.eql_v3_json) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_jsonb_json(a jsonb, b public.eql_v3_json_search) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '<@'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '<@'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.jsonb_blocked_contains_json_jsonb, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.jsonb_blocked_contains_jsonb_json, LEFTARG = jsonb, - RIGHTARG = public.eql_v3_json + RIGHTARG = public.eql_v3_json_search ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.jsonb_blocked_contained_json_jsonb, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.jsonb_blocked_contained_jsonb_json, LEFTARG = jsonb, - RIGHTARG = public.eql_v3_json + RIGHTARG = public.eql_v3_json_search ); diff --git a/src/v3/jsonb/functions.sql b/src/v3/json/functions.sql similarity index 90% rename from src/v3/jsonb/functions.sql rename to src/v3/json/functions.sql index d429735c2..8b75b7ff9 100644 --- a/src/v3/jsonb/functions.sql +++ b/src/v3/json/functions.sql @@ -1,9 +1,9 @@ -- REQUIRE: src/v3/schema.sql --- REQUIRE: src/v3/jsonb/types.sql +-- REQUIRE: src/v3/json/types.sql -- REQUIRE: src/v3/sem/ope_cllw/types.sql -- REQUIRE: src/v3/sem/ope_cllw/functions.sql ---! @file v3/jsonb/functions.sql +--! @file v3/json/functions.sql --! @brief Extractors, containment engine, and path/array functions for the --! eql_v3 encrypted-JSONB (SteVec) surface. --! @@ -69,9 +69,9 @@ $$ LANGUAGE plpgsql; --! @brief Extract selector (s) from a ste_vec entry. The DOMAIN CHECK --! guarantees `s` is present, so this is a simple field access. ---! @param entry public.eql_v3_jsonb_entry +--! @param entry public.eql_v3_json_entry --! @return text The selector value. -CREATE FUNCTION eql_v3.selector(entry public.eql_v3_jsonb_entry) +CREATE FUNCTION eql_v3.selector(entry public.eql_v3_json_entry) RETURNS text LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -82,16 +82,16 @@ $$; -- Equality-term extractor (XOR-aware: coalesce(hm, op)) ------------------------------------------------------------------------------ ---! @brief XOR-aware equality term extractor for public.eql_v3_jsonb_entry. +--! @brief XOR-aware equality term extractor for public.eql_v3_json_entry. --! --! Returns the bytea of whichever deterministic term the sv entry carries — --! `hm` (HMAC-256) or `op` (CLLW OPE). The two byte distributions are disjoint --! by construction, so byte equality on the coalesce is unambiguous. Canonical --! equality extractor used by `=` / `<>` on jsonb_entry. --! ---! @param entry public.eql_v3_jsonb_entry +--! @param entry public.eql_v3_json_entry --! @return bytea Decoded `hm` or `op` bytes (NULL if entry is NULL). -CREATE FUNCTION eql_v3.eq_term(entry public.eql_v3_jsonb_entry) +CREATE FUNCTION eql_v3.eq_term(entry public.eql_v3_json_entry) RETURNS bytea LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -105,7 +105,7 @@ $$; --! @brief Extract the CLLW OPE index term from a ste_vec entry. --! --! An sv-element `op` term is only ever present on an sv element, never at a ---! root encrypted value, so the typed overload accepts public.eql_v3_jsonb_entry — +--! root encrypted value, so the typed overload accepts public.eql_v3_json_entry — --! the jsonb_entry twin of the generated scalar `eql_v3.ord_term` --! extractors. Returns SQL NULL when `op` is absent (the strict `->>` / --! `decode` chain propagates it), so btree NULL-filters such rows from range @@ -115,10 +115,10 @@ $$; --! structurally with no custom operator class (Supabase/managed-Postgres --! safe). --! ---! @param entry public.eql_v3_jsonb_entry +--! @param entry public.eql_v3_json_entry --! @return eql_v3_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when --! `op` is absent. -CREATE FUNCTION eql_v3.ord_term(entry public.eql_v3_jsonb_entry) +CREATE FUNCTION eql_v3.ord_term(entry public.eql_v3_json_entry) RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -216,7 +216,7 @@ COMMENT ON FUNCTION eql_v3.jsonb_array(jsonb) IS --! @note Public raw-`jsonb[]` containment helper over the extracted --! deterministic fields — the function-form entrypoint for containment on --! platforms without operator support (Supabase/PostgREST). The typed ---! `public.eql_v3_json` `@>` operator does NOT call this function — it binds to +--! `public.eql_v3_json_search` `@>` operator does NOT call this function — it binds to --! `eql_v3.ste_vec_contains` instead — but both agree on the result (a --! parity test pins this). Also the documented GIN index expression --! (`eql_v3.jsonb_array(col)`); see docs/reference/database-indexes.md. @@ -237,7 +237,7 @@ COMMENT ON FUNCTION eql_v3.jsonb_contains(jsonb, jsonb) IS --! @return boolean True if all elements of a are contained in b. --! @note Public raw-`jsonb[]` reverse-containment helper — the function-form --! entrypoint for `<@` on platforms without operator support. The typed ---! `public.eql_v3_json` `<@` operator binds to `eql_v3.ste_vec_contains` instead, +--! `public.eql_v3_json_search` `<@` operator binds to `eql_v3.ste_vec_contains` instead, --! but both agree on the result. CREATE FUNCTION eql_v3.jsonb_contained_by(a jsonb, b jsonb) RETURNS boolean @@ -285,7 +285,7 @@ AS $$ _a := a[idx]; result := result OR ( eql_v3.selector(_a) = eql_v3.selector(b) - AND eql_v3.eq_term(_a::public.eql_v3_jsonb_entry) = eql_v3.eq_term(b::public.eql_v3_jsonb_entry) + AND eql_v3.eq_term(_a::public.eql_v3_json_entry) = eql_v3.eq_term(b::public.eql_v3_json_entry) ); EXIT WHEN result; END LOOP; @@ -299,11 +299,11 @@ $$ LANGUAGE plpgsql; --! Empty b is always contained. Each element of b must match selector + eq_term --! in some element of a. --! ---! @param a public.eql_v3_json Container. ---! @param b public.eql_v3_json Elements to find. +--! @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. --! @see eql_v3.ste_vec_contains(jsonb[], jsonb) -CREATE FUNCTION eql_v3.ste_vec_contains(a public.eql_v3_json, b public.eql_v3_json) +CREATE FUNCTION eql_v3.ste_vec_contains(a public.eql_v3_json_search, b public.eql_v3_json_search) RETURNS boolean IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public @@ -344,18 +344,18 @@ $$ LANGUAGE plpgsql; --! --! Returns one jsonb_entry row per matching encrypted element. Returns empty --! set on no match. It deliberately does not wrap multiple matches as an ---! public.eql_v3_json document, because the root document domain requires an `sv` ---! array and single leaves belong to public.eql_v3_jsonb_entry. +--! public.eql_v3_json_search document, because the root document domain requires an `sv` +--! array and single leaves belong to public.eql_v3_json_entry. --! --! @param val jsonb encrypted EQL payload with `sv`. --! @param selector text Selector hash (`s` value). ---! @return SETOF public.eql_v3_jsonb_entry Matching encrypted entries. +--! @return SETOF public.eql_v3_json_entry Matching encrypted entries. --! @see eql_v3.jsonb_path_query_first CREATE FUNCTION eql_v3.jsonb_path_query(val jsonb, selector text) - RETURNS SETOF public.eql_v3_jsonb_entry + RETURNS SETOF public.eql_v3_json_entry LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ - SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_jsonb_entry + SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_entry FROM jsonb_array_elements(val -> 'sv') elem WHERE elem ->> 's' = selector $$; @@ -383,12 +383,12 @@ COMMENT ON FUNCTION eql_v3.jsonb_path_exists(jsonb, text) IS --! @brief Get the first sv element matching `selector`, or NULL. --! @param val jsonb encrypted EQL payload. --! @param selector text Selector hash to match. ---! @return public.eql_v3_jsonb_entry First matching element or NULL. +--! @return public.eql_v3_json_entry First matching element or NULL. CREATE FUNCTION eql_v3.jsonb_path_query_first(val jsonb, selector text) - RETURNS public.eql_v3_jsonb_entry + RETURNS public.eql_v3_json_entry LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ - SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_jsonb_entry + SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_entry FROM jsonb_array_elements(val -> 'sv') elem WHERE elem ->> 's' = selector LIMIT 1 @@ -424,10 +424,10 @@ $$ LANGUAGE plpgsql; --! @brief Extract elements of an encrypted JSONB array as rows. --! @param val jsonb encrypted EQL payload (must have `a` flag true). ---! @return SETOF public.eql_v3_jsonb_entry One row per element (metadata preserved). +--! @return SETOF public.eql_v3_json_entry One row per element (metadata preserved). --! @throws Exception 'cannot extract elements from non-array' if not an array. CREATE FUNCTION eql_v3.jsonb_array_elements(val jsonb) - RETURNS SETOF public.eql_v3_jsonb_entry + RETURNS SETOF public.eql_v3_json_entry IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -445,7 +445,7 @@ AS $$ FOR idx IN 1..array_length(sv, 1) LOOP item = sv[idx]; - RETURN NEXT (meta || item)::public.eql_v3_jsonb_entry; + RETURN NEXT (meta || item)::public.eql_v3_json_entry; END LOOP; RETURN; diff --git a/src/v3/jsonb/operators.sql b/src/v3/json/operators.sql similarity index 65% rename from src/v3/jsonb/operators.sql rename to src/v3/json/operators.sql index 12c6ea7e5..41a729ca8 100644 --- a/src/v3/jsonb/operators.sql +++ b/src/v3/json/operators.sql @@ -1,10 +1,10 @@ -- REQUIRE: src/v3/schema.sql --- REQUIRE: src/v3/jsonb/types.sql --- REQUIRE: src/v3/jsonb/functions.sql +-- REQUIRE: src/v3/json/types.sql +-- REQUIRE: src/v3/json/functions.sql -- REQUIRE: src/v3/sem/ope_cllw/types.sql ---! @file v3/jsonb/operators.sql ---! @brief Operators on public.eql_v3_json and public.eql_v3_jsonb_entry. +--! @file v3/json/operators.sql +--! @brief Operators on public.eql_v3_json_search and public.eql_v3_json_entry. ------------------------------------------------------------------------------ -- -> field accessor (returns jsonb_entry) @@ -21,17 +21,17 @@ --! parameter (`$1`, the Proxy interface) or an explicit cast (`col -> 'sel'::%text`). --! A bare untyped literal (`col -> 'sel'`) resolves to the NATIVE `jsonb -> %text` --! operator and silently returns native jsonb semantics (a root-key lookup, ---! typically NULL), NOT this operator: PostgreSQL reduces the `public.eql_v3_json` +--! typically NULL), NOT this operator: PostgreSQL reduces the `public.eql_v3_json_search` --! domain to its base type `jsonb` when resolving an unknown-typed RHS, and the --! native base-type operator wins the exact-match tiebreak. This is intrinsic to --! the domain type-kind and applies to the native-jsonb blockers too. See --! the "Typed operands" caveat in docs/reference/json-support.md. --! ---! @param e public.eql_v3_json Root encrypted payload. +--! @param e public.eql_v3_json_search Root encrypted payload. --! @param selector text Selector hash. ---! @return public.eql_v3_jsonb_entry Matching entry merged with root meta, or NULL. -CREATE FUNCTION eql_v3."->"(e public.eql_v3_json, selector text) - RETURNS public.eql_v3_jsonb_entry +--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL. +CREATE FUNCTION eql_v3."->"(e public.eql_v3_json_search, selector text) + RETURNS public.eql_v3_json_entry LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT ( @@ -41,40 +41,40 @@ AS $$ '$.sv[*] ? (@.s == $sel)'::jsonpath, jsonb_build_object('sel', selector) ) - )::public.eql_v3_jsonb_entry + )::public.eql_v3_json_entry $$; CREATE OPERATOR ->( FUNCTION=eql_v3."->", - LEFTARG=public.eql_v3_json, + LEFTARG=public.eql_v3_json_search, RIGHTARG=text ); --! @brief -> operator with integer array index (0-based, JSONB convention). ---! @param e public.eql_v3_json Encrypted sv-array payload. +--! @param e public.eql_v3_json_search Encrypted sv-array payload. --! @param selector integer Array index. ---! @return public.eql_v3_jsonb_entry Matching entry merged with root meta, or NULL. -CREATE FUNCTION eql_v3."->"(e public.eql_v3_json, selector integer) - RETURNS public.eql_v3_jsonb_entry +--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL. +CREATE FUNCTION eql_v3."->"(e public.eql_v3_json_search, selector integer) + RETURNS public.eql_v3_json_entry LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT CASE WHEN eql_v3_internal.is_ste_vec_array(e) THEN -- NOTE: `e::jsonb` makes the native-jsonb traversal explicit. `'sv'` is an - -- unknown-typed literal, so `e -> 'sv'` already flattens `public.eql_v3_json` to + -- unknown-typed literal, so `e -> 'sv'` already flattens `public.eql_v3_json_search` to -- its base type and binds native `jsonb -> text` (see the @warning above) — - -- the custom `->(public.eql_v3_json, text)` operator does NOT capture a bare + -- the custom `->(public.eql_v3_json_search, text)` operator does NOT capture a bare -- untyped literal. The cast documents that intent and guards the `-> selector` - -- (integer) hop from ever resolving to the v3 `->(public.eql_v3_json, integer)` + -- (integer) hop from ever resolving to the v3 `->(public.eql_v3_json_search, integer)` -- operator instead of native array access. - (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::public.eql_v3_jsonb_entry + (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::public.eql_v3_json_entry ELSE NULL END $$; CREATE OPERATOR ->( FUNCTION=eql_v3."->", - LEFTARG=public.eql_v3_json, + LEFTARG=public.eql_v3_json_search, RIGHTARG=integer ); @@ -88,10 +88,10 @@ CREATE OPERATOR ->( --! Intentional v2 parity: this serializes the entire matched jsonb_entry --! object as JSON text. It does not decrypt or return scalar plaintext like --! native `jsonb ->>`. ---! @param e public.eql_v3_json Encrypted payload. +--! @param e public.eql_v3_json_search Encrypted payload. --! @param selector text Field selector hash. --! @return text The matching entry as text. -CREATE FUNCTION eql_v3."->>"(e public.eql_v3_json, selector text) +CREATE FUNCTION eql_v3."->>"(e public.eql_v3_json_search, selector text) RETURNS text LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -100,16 +100,16 @@ $$; CREATE OPERATOR ->> ( FUNCTION=eql_v3."->>", - LEFTARG=public.eql_v3_json, + LEFTARG=public.eql_v3_json_search, RIGHTARG=text ); --! @brief ->> operator with integer array index. Inlinable alias of --! ->(json, integer) coerced to text. ---! @param e public.eql_v3_json Encrypted sv-array payload. +--! @param e public.eql_v3_json_search Encrypted sv-array payload. --! @param selector integer Array index. --! @return text The matching entry as text. -CREATE FUNCTION eql_v3."->>"(e public.eql_v3_json, selector integer) +CREATE FUNCTION eql_v3."->>"(e public.eql_v3_json_search, selector integer) RETURNS text LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -118,7 +118,7 @@ $$; CREATE OPERATOR ->> ( FUNCTION=eql_v3."->>", - LEFTARG=public.eql_v3_json, + LEFTARG=public.eql_v3_json_search, RIGHTARG=integer ); @@ -127,11 +127,11 @@ CREATE OPERATOR ->> ( ------------------------------------------------------------------------------ --! @brief @> contains operator (document, document). ---! @param a public.eql_v3_json Container. ---! @param b public.eql_v3_json Contained value. +--! @param a public.eql_v3_json_search Container. +--! @param b public.eql_v3_json_search Contained value. --! @return boolean True if a contains b. --! @see eql_v3.ste_vec_contains -CREATE FUNCTION eql_v3."@>"(a public.eql_v3_json, b public.eql_v3_json) +CREATE FUNCTION eql_v3."@>"(a public.eql_v3_json_search, b public.eql_v3_json_search) RETURNS boolean LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -140,19 +140,19 @@ $$; CREATE OPERATOR @>( FUNCTION=eql_v3."@>", - LEFTARG=public.eql_v3_json, - RIGHTARG=public.eql_v3_json + LEFTARG=public.eql_v3_json_search, + RIGHTARG=public.eql_v3_json_search ); ---! @brief @> contains operator with an query_jsonb needle. +--! @brief @> contains operator with an query_json needle. --! --! Inlines to native `jsonb @>` over `eql_v3.to_ste_vec_query(a)::jsonb`, so a --! functional GIN index on the same expression engages. --! ---! @param a public.eql_v3_json Container. ---! @param b eql_v3.query_jsonb Query payload. +--! @param a public.eql_v3_json_search Container. +--! @param b eql_v3.query_json Query payload. --! @return boolean True if a contains b. -CREATE FUNCTION eql_v3."@>"(a public.eql_v3_json, b eql_v3.query_jsonb) +CREATE FUNCTION eql_v3."@>"(a public.eql_v3_json_search, b eql_v3.query_json) RETURNS boolean LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -161,8 +161,8 @@ $$; CREATE OPERATOR @>( FUNCTION=eql_v3."@>", - LEFTARG=public.eql_v3_json, - RIGHTARG=eql_v3.query_jsonb + LEFTARG=public.eql_v3_json_search, + RIGHTARG=eql_v3.query_json ); --! @brief @> contains operator with a single jsonb_entry needle. @@ -170,10 +170,10 @@ CREATE OPERATOR @>( --! Wraps the entry into a single-element sv array (stripping `c`) and reduces --! to the same `to_ste_vec_query(a)::jsonb @> needle::jsonb` form. --! ---! @param a public.eql_v3_json Container. ---! @param b public.eql_v3_jsonb_entry Single entry. +--! @param a public.eql_v3_json_search Container. +--! @param b public.eql_v3_json_entry Single entry. --! @return boolean True if a contains an sv entry matching b. -CREATE FUNCTION eql_v3."@>"(a public.eql_v3_json, b public.eql_v3_jsonb_entry) +CREATE FUNCTION eql_v3."@>"(a public.eql_v3_json_search, b public.eql_v3_json_entry) RETURNS boolean LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -194,8 +194,8 @@ $$; CREATE OPERATOR @>( FUNCTION=eql_v3."@>", - LEFTARG=public.eql_v3_json, - RIGHTARG=public.eql_v3_jsonb_entry + LEFTARG=public.eql_v3_json_search, + RIGHTARG=public.eql_v3_json_entry ); ------------------------------------------------------------------------------ @@ -203,10 +203,10 @@ CREATE OPERATOR @>( ------------------------------------------------------------------------------ --! @brief <@ contained-by operator (document, document). ---! @param a public.eql_v3_json Contained value. ---! @param b public.eql_v3_json Container. +--! @param a public.eql_v3_json_search Contained value. +--! @param b public.eql_v3_json_search Container. --! @return boolean True if a is contained by b. -CREATE FUNCTION eql_v3."<@"(a public.eql_v3_json, b public.eql_v3_json) +CREATE FUNCTION eql_v3."<@"(a public.eql_v3_json_search, b public.eql_v3_json_search) RETURNS boolean LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -215,15 +215,15 @@ $$; CREATE OPERATOR <@( FUNCTION=eql_v3."<@", - LEFTARG=public.eql_v3_json, - RIGHTARG=public.eql_v3_json + LEFTARG=public.eql_v3_json_search, + RIGHTARG=public.eql_v3_json_search ); ---! @brief <@ contained-by operator with an query_jsonb LHS. ---! @param a eql_v3.query_jsonb Query payload. ---! @param b public.eql_v3_json Container. +--! @brief <@ contained-by operator with an query_json LHS. +--! @param a eql_v3.query_json Query payload. +--! @param b public.eql_v3_json_search Container. --! @return boolean True if b contains a. -CREATE FUNCTION eql_v3."<@"(a eql_v3.query_jsonb, b public.eql_v3_json) +CREATE FUNCTION eql_v3."<@"(a eql_v3.query_json, b public.eql_v3_json_search) RETURNS boolean LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -232,15 +232,15 @@ $$; CREATE OPERATOR <@( FUNCTION=eql_v3."<@", - LEFTARG=eql_v3.query_jsonb, - RIGHTARG=public.eql_v3_json + LEFTARG=eql_v3.query_json, + RIGHTARG=public.eql_v3_json_search ); --! @brief <@ contained-by operator with a jsonb_entry LHS. ---! @param a public.eql_v3_jsonb_entry Single entry. ---! @param b public.eql_v3_json Container. +--! @param a public.eql_v3_json_entry Single entry. +--! @param b public.eql_v3_json_search Container. --! @return boolean True if b contains a. -CREATE FUNCTION eql_v3."<@"(a public.eql_v3_jsonb_entry, b public.eql_v3_json) +CREATE FUNCTION eql_v3."<@"(a public.eql_v3_json_entry, b public.eql_v3_json_search) RETURNS boolean LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -249,8 +249,8 @@ $$; CREATE OPERATOR <@( FUNCTION=eql_v3."<@", - LEFTARG=public.eql_v3_jsonb_entry, - RIGHTARG=public.eql_v3_json + LEFTARG=public.eql_v3_json_entry, + RIGHTARG=public.eql_v3_json_search ); ------------------------------------------------------------------------------ @@ -258,10 +258,10 @@ CREATE OPERATOR <@( ------------------------------------------------------------------------------ --! @brief Equality on jsonb_entry via eq_term (hm-or-op byte equality). ---! @param a public.eql_v3_jsonb_entry Left operand ---! @param b public.eql_v3_jsonb_entry Right operand +--! @param a public.eql_v3_json_entry Left operand +--! @param b public.eql_v3_json_entry Right operand --! @return boolean True if the entries are equal -CREATE FUNCTION eql_v3.eq(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_json_entry, b public.eql_v3_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -270,8 +270,8 @@ $$; CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_jsonb_entry, - RIGHTARG = public.eql_v3_jsonb_entry, + LEFTARG = public.eql_v3_json_entry, + RIGHTARG = public.eql_v3_json_entry, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, @@ -279,10 +279,10 @@ CREATE OPERATOR = ( ); --! @brief Inequality on jsonb_entry via eq_term. ---! @param a public.eql_v3_jsonb_entry Left operand ---! @param b public.eql_v3_jsonb_entry Right operand +--! @param a public.eql_v3_json_entry Left operand +--! @param b public.eql_v3_json_entry Right operand --! @return boolean True if the entries are not equal -CREATE FUNCTION eql_v3.neq(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_json_entry, b public.eql_v3_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -291,8 +291,8 @@ $$; CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_jsonb_entry, - RIGHTARG = public.eql_v3_jsonb_entry, + LEFTARG = public.eql_v3_json_entry, + RIGHTARG = public.eql_v3_json_entry, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, @@ -300,10 +300,10 @@ CREATE OPERATOR <> ( ); --! @brief Less-than on jsonb_entry via the CLLW OPE term (native bytea order). ---! @param a public.eql_v3_jsonb_entry Left operand ---! @param b public.eql_v3_jsonb_entry Right operand +--! @param a public.eql_v3_json_entry Left operand +--! @param b public.eql_v3_json_entry Right operand --! @return boolean True if a is less than b -CREATE FUNCTION eql_v3.lt(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b public.eql_v3_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -312,8 +312,8 @@ $$; CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_jsonb_entry, - RIGHTARG = public.eql_v3_jsonb_entry, + LEFTARG = public.eql_v3_json_entry, + RIGHTARG = public.eql_v3_json_entry, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, @@ -321,10 +321,10 @@ CREATE OPERATOR < ( ); --! @brief Less-than-or-equal on jsonb_entry via the CLLW OPE term. ---! @param a public.eql_v3_jsonb_entry Left operand ---! @param b public.eql_v3_jsonb_entry Right operand +--! @param a public.eql_v3_json_entry Left operand +--! @param b public.eql_v3_json_entry Right operand --! @return boolean True if a is less than or equal to b -CREATE FUNCTION eql_v3.lte(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b public.eql_v3_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -333,8 +333,8 @@ $$; CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_jsonb_entry, - RIGHTARG = public.eql_v3_jsonb_entry, + LEFTARG = public.eql_v3_json_entry, + RIGHTARG = public.eql_v3_json_entry, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, @@ -342,10 +342,10 @@ CREATE OPERATOR <= ( ); --! @brief Greater-than on jsonb_entry via the CLLW OPE term. ---! @param a public.eql_v3_jsonb_entry Left operand ---! @param b public.eql_v3_jsonb_entry Right operand +--! @param a public.eql_v3_json_entry Left operand +--! @param b public.eql_v3_json_entry Right operand --! @return boolean True if a is greater than b -CREATE FUNCTION eql_v3.gt(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b public.eql_v3_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -354,8 +354,8 @@ $$; CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_jsonb_entry, - RIGHTARG = public.eql_v3_jsonb_entry, + LEFTARG = public.eql_v3_json_entry, + RIGHTARG = public.eql_v3_json_entry, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, @@ -363,10 +363,10 @@ CREATE OPERATOR > ( ); --! @brief Greater-than-or-equal on jsonb_entry via the CLLW OPE term. ---! @param a public.eql_v3_jsonb_entry Left operand ---! @param b public.eql_v3_jsonb_entry Right operand +--! @param a public.eql_v3_json_entry Left operand +--! @param b public.eql_v3_json_entry Right operand --! @return boolean True if a is greater than or equal to b -CREATE FUNCTION eql_v3.gte(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b public.eql_v3_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -375,8 +375,8 @@ $$; CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_jsonb_entry, - RIGHTARG = public.eql_v3_jsonb_entry, + LEFTARG = public.eql_v3_json_entry, + RIGHTARG = public.eql_v3_json_entry, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, diff --git a/src/v3/jsonb/types.sql b/src/v3/json/types.sql similarity index 82% rename from src/v3/jsonb/types.sql rename to src/v3/json/types.sql index a0faf1981..ebc442674 100644 --- a/src/v3/jsonb/types.sql +++ b/src/v3/json/types.sql @@ -1,14 +1,14 @@ -- REQUIRE: src/v3/schema.sql ---! @file v3/jsonb/types.sql +--! @file v3/json/types.sql --! @brief Domain types for the eql_v3 encrypted-JSONB (SteVec) surface. --! --! Three jsonb-backed domains (none over another domain — operators resolve --! against the ultimate base type jsonb, so the native-jsonb firewall in --! blockers.sql can attach): ---! - public.eql_v3_json — storage/root: an EQL envelope object ({i, v, ...}). ---! - public.eql_v3_jsonb_entry — a single sv element (returned by `->`). ---! - eql_v3.query_jsonb — a containment needle (sv elements, no ciphertext). +--! - public.eql_v3_json_search — storage/root: an EQL envelope object ({i, v, ...}). +--! - public.eql_v3_json_entry — a single sv element (returned by `->`). +--! - eql_v3.query_json — a containment needle (sv elements, no ciphertext). --! @brief Validate a single SteVec entry payload. --! @internal @@ -39,7 +39,7 @@ $$; --! string `s`, no ciphertext, and exactly one string term (`hm` XOR --! `op`). --! @note plpgsql, not LANGUAGE sql (issues #353/#354): the only caller is the ---! eql_v3.query_jsonb domain CHECK, where a SQL function can never be +--! eql_v3.query_json domain CHECK, where a SQL function can never be --! inlined (and the CHECK itself cannot absorb this body — it needs a --! subquery over the sv elements, which CHECK constraints forbid). plpgsql --! caches its plan across calls instead of paying the per-call SQL-function @@ -106,25 +106,25 @@ $$; --! is `{i, v, sv}` with no root ciphertext. The CHECK now also requires an `sv` --! array, so the domain accepts only SteVec **document** payloads and rejects --! encrypted *scalar* payloads (which carry `c`/`hm`/`ob` but no `sv`) — this is ---! what keeps `public.eql_v3_json` a typed document domain rather than a generic +--! what keeps `public.eql_v3_json_search` a typed document domain rather than a generic --! encrypted envelope. The firewall in blockers.sql attaches to this domain to --! stop native jsonb operators from reaching a column value. --! --! @note Constructing from inline JSON uses the standard DOMAIN cast: ---! `'{"i":{},"v":3,"sv":[...]}'::public.eql_v3_json`. +--! `'{"i":{},"v":3,"sv":[...]}'::public.eql_v3_json_search`. DO $$ BEGIN IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_json' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_json_search' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_json AS jsonb + CREATE DOMAIN public.eql_v3_json_search AS jsonb CHECK ( public.eql_v3_is_valid_ste_vec_document_payload(VALUE) ); END IF; - COMMENT ON DOMAIN public.eql_v3_json IS 'EQL encrypted JSONB document (containment, equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_json_search IS 'EQL encrypted JSONB document (containment, equality, ordering)'; END $$; @@ -137,7 +137,7 @@ $$; --! extractors `eql_v3.eq_term` / `eql_v3.ord_term`. Extra fields (`a`, root --! `i`/`v` merged in by `->`) are allowed. --! ---! @see src/v3/jsonb/operators.sql +--! @see src/v3/json/operators.sql --! --! @internal --! Implementation note (issue #354): the CHECK is an INLINE expression, not a @@ -156,9 +156,9 @@ DO $$ BEGIN IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_jsonb_entry' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_json_entry' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_jsonb_entry AS jsonb + CREATE DOMAIN public.eql_v3_json_entry AS jsonb CHECK ( VALUE IS NULL OR COALESCE( @@ -175,7 +175,7 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_jsonb_entry IS 'EQL encrypted JSONB leaf entry (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_json_entry IS 'EQL encrypted JSONB leaf entry (equality, ordering)'; END $$; @@ -188,36 +188,36 @@ $$; --! `jsonb @>`. --! --! @note Construct from inline JSON via the DOMAIN cast: ---! `'{"sv":[{"s":"","hm":""}]}'::eql_v3.query_jsonb`. +--! `'{"sv":[{"s":"","hm":""}]}'::eql_v3.query_json`. --! @see eql_v3.to_ste_vec_query --! --! @internal --! Implementation note (issue #354): this CHECK CANNOT be inlined like ---! public.eql_v3_jsonb_entry's — validating the sv elements requires a subquery +--! public.eql_v3_json_entry's — validating the sv elements requires a subquery --! (`NOT EXISTS (SELECT ... FROM jsonb_array_elements(...))`), and CHECK --! constraints forbid subqueries. The validator is plpgsql instead (cached --! plan; substantially cheaper per call than a non-inlined LANGUAGE sql --! function — the same finding as issue #353), since this cast sits on the --! per-query hot path of every containment scenario ---! (`$1::jsonb::eql_v3.query_jsonb`). +--! (`$1::jsonb::eql_v3.query_json`). --! @endinternal DO $$ BEGIN IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_jsonb' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_json' AND typnamespace = 'eql_v3'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_jsonb AS jsonb + CREATE DOMAIN eql_v3.query_json AS jsonb CHECK ( public.eql_v3_is_valid_ste_vec_query_payload(VALUE) ); END IF; - COMMENT ON DOMAIN eql_v3.query_jsonb IS 'EQL JSONB query operand (containment)'; + COMMENT ON DOMAIN eql_v3.query_json IS 'EQL JSONB query operand (containment)'; END $$; ---! @brief Convert a public.eql_v3_json to a query_jsonb needle. +--! @brief Convert a public.eql_v3_json_search to a query_json needle. --! --! Normalises each sv element down to the matching-relevant fields: `s` plus --! exactly one of `hm` / `op`. Other fields (`c`, `a`, `i`/`v`, anything else) @@ -225,11 +225,11 @@ $$; --! Designed for use as a functional GIN index expression: --! `GIN (eql_v3.to_ste_vec_query(col)::jsonb jsonb_path_ops)`. --! ---! @param e public.eql_v3_json Source encrypted payload ---! @return eql_v3.query_jsonb Query-shaped needle, sv elements normalised. ---! @see eql_v3.query_jsonb -CREATE FUNCTION eql_v3.to_ste_vec_query(e public.eql_v3_json) - RETURNS eql_v3.query_jsonb +--! @param e public.eql_v3_json_search Source encrypted payload +--! @return eql_v3.query_json Query-shaped needle, sv elements normalised. +--! @see eql_v3.query_json +CREATE FUNCTION eql_v3.to_ste_vec_query(e public.eql_v3_json_search) + RETURNS eql_v3.query_json LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT jsonb_build_object( @@ -247,9 +247,9 @@ AS $$ FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem), '[]'::jsonb ) - )::eql_v3.query_jsonb + )::eql_v3.query_json $$; -CREATE CAST (public.eql_v3_json AS eql_v3.query_jsonb) +CREATE CAST (public.eql_v3_json_search AS eql_v3.query_json) WITH FUNCTION eql_v3.to_ste_vec_query AS ASSIGNMENT; diff --git a/src/v3/scalars/json/json_functions.sql b/src/v3/scalars/json/json_functions.sql new file mode 100644 index 000000000..3727c205c --- /dev/null +++ b/src/v3/scalars/json/json_functions.sql @@ -0,0 +1,403 @@ +-- AUTOMATICALLY GENERATED FILE. +-- REQUIRE: src/v3/schema.sql +-- REQUIRE: src/v3/scalars/json/json_types.sql +-- REQUIRE: src/v3/scalars/functions.sql + +--! @file encrypted_domain/json/json_functions.sql +--! @brief Functions for public.eql_v3_json. + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b public.eql_v3_json +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a jsonb +--! @param b public.eql_v3_json +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b public.eql_v3_json +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a jsonb +--! @param b public.eql_v3_json +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b public.eql_v3_json +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a jsonb +--! @param b public.eql_v3_json +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b public.eql_v3_json +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a jsonb +--! @param b public.eql_v3_json +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b public.eql_v3_json +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a jsonb +--! @param b public.eql_v3_json +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b public.eql_v3_json +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a jsonb +--! @param b public.eql_v3_json +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b public.eql_v3_json +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a jsonb +--! @param b public.eql_v3_json +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b public.eql_v3_json +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a jsonb +--! @param b public.eql_v3_json +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param selector text +--! @return public.eql_v3_json +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_json, selector text) +RETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param selector integer +--! @return public.eql_v3_json +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_json, selector integer) +RETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a jsonb +--! @param selector public.eql_v3_json +--! @return public.eql_v3_json +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_json) +RETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_json, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_json, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a jsonb +--! @param selector public.eql_v3_json +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_json) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_json, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_json, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_json, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_json, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_json, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_json, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_json, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_json, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_json, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_json, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_json, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b public.eql_v3_json +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_json, b public.eql_v3_json) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_json, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a jsonb +--! @param b public.eql_v3_json +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_json) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; diff --git a/src/v3/scalars/json/json_operators.sql b/src/v3/scalars/json/json_operators.sql new file mode 100644 index 000000000..40de7fd3b --- /dev/null +++ b/src/v3/scalars/json/json_operators.sql @@ -0,0 +1,227 @@ +-- AUTOMATICALLY GENERATED FILE. +-- REQUIRE: src/v3/schema.sql +-- REQUIRE: src/v3/scalars/json/json_types.sql +-- REQUIRE: src/v3/scalars/json/json_functions.sql + +--! @file encrypted_domain/json/json_operators.sql +--! @brief Operators for public.eql_v3_json. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_json, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_json, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_json, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_json, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_json, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_json, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_json, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_json, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_json, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_json, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_json, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_json, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_json, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_json +); diff --git a/src/v3/scalars/json/json_types.sql b/src/v3/scalars/json/json_types.sql new file mode 100644 index 000000000..bebe5d0b6 --- /dev/null +++ b/src/v3/scalars/json/json_types.sql @@ -0,0 +1,26 @@ +-- AUTOMATICALLY GENERATED FILE. +-- REQUIRE: src/v3/schema.sql + +--! @file v3/scalars/json/json_types.sql +--! @brief Encrypted-domain types for json. + +DO $$ +BEGIN + --! @brief Encrypted domain public.eql_v3_json. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'eql_v3_json' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.eql_v3_json AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.eql_v3_json IS 'EQL encrypted json (storage only)'; +END +$$; diff --git a/tests/sqlx/snapshots/eql_v3_public_surface.txt b/tests/sqlx/snapshots/eql_v3_public_surface.txt index 0573a4edd..13962cd2d 100644 --- a/tests/sqlx/snapshots/eql_v3_public_surface.txt +++ b/tests/sqlx/snapshots/eql_v3_public_surface.txt @@ -10,7 +10,7 @@ aggregate eql_v3.max(public.eql_v3_double_ord_ore) aggregate eql_v3.max(public.eql_v3_integer_ord) aggregate eql_v3.max(public.eql_v3_integer_ord_ope) aggregate eql_v3.max(public.eql_v3_integer_ord_ore) -aggregate eql_v3.max(public.eql_v3_jsonb_entry) +aggregate eql_v3.max(public.eql_v3_json_entry) aggregate eql_v3.max(public.eql_v3_numeric_ord) aggregate eql_v3.max(public.eql_v3_numeric_ord_ope) aggregate eql_v3.max(public.eql_v3_numeric_ord_ore) @@ -40,7 +40,7 @@ aggregate eql_v3.min(public.eql_v3_double_ord_ore) aggregate eql_v3.min(public.eql_v3_integer_ord) aggregate eql_v3.min(public.eql_v3_integer_ord_ope) aggregate eql_v3.min(public.eql_v3_integer_ord_ore) -aggregate eql_v3.min(public.eql_v3_jsonb_entry) +aggregate eql_v3.min(public.eql_v3_json_entry) aggregate eql_v3.min(public.eql_v3_numeric_ord) aggregate eql_v3.min(public.eql_v3_numeric_ord_ope) aggregate eql_v3.min(public.eql_v3_numeric_ord_ore) @@ -58,17 +58,17 @@ aggregate eql_v3.min(public.eql_v3_text_search_ore) aggregate eql_v3.min(public.eql_v3_timestamp_ord) aggregate eql_v3.min(public.eql_v3_timestamp_ord_ope) aggregate eql_v3.min(public.eql_v3_timestamp_ord_ore) -cast public.eql_v3_json -> eql_v3.query_jsonb -function eql_v3.->(e public.eql_v3_json, selector integer) -function eql_v3.->(e public.eql_v3_json, selector text) -function eql_v3.->>(e public.eql_v3_json, selector integer) -function eql_v3.->>(e public.eql_v3_json, selector text) -function eql_v3.<@(a eql_v3.query_jsonb, b public.eql_v3_json) -function eql_v3.<@(a public.eql_v3_json, b public.eql_v3_json) -function eql_v3.<@(a public.eql_v3_jsonb_entry, b public.eql_v3_json) -function eql_v3.@>(a public.eql_v3_json, b eql_v3.query_jsonb) -function eql_v3.@>(a public.eql_v3_json, b public.eql_v3_json) -function eql_v3.@>(a public.eql_v3_json, b public.eql_v3_jsonb_entry) +cast public.eql_v3_json_search -> eql_v3.query_json +function eql_v3.->(e public.eql_v3_json_search, selector integer) +function eql_v3.->(e public.eql_v3_json_search, selector text) +function eql_v3.->>(e public.eql_v3_json_search, selector integer) +function eql_v3.->>(e public.eql_v3_json_search, selector text) +function eql_v3.<@(a eql_v3.query_json, b public.eql_v3_json_search) +function eql_v3.<@(a public.eql_v3_json_entry, b public.eql_v3_json_search) +function eql_v3.<@(a public.eql_v3_json_search, b public.eql_v3_json_search) +function eql_v3.@>(a public.eql_v3_json_search, b eql_v3.query_json) +function eql_v3.@>(a public.eql_v3_json_search, b public.eql_v3_json_entry) +function eql_v3.@>(a public.eql_v3_json_search, b public.eql_v3_json_search) function eql_v3.ciphertext(val jsonb) function eql_v3.contained_by(a eql_v3.query_text_match, b public.eql_v3_text_match) function eql_v3.contained_by(a eql_v3.query_text_search, b public.eql_v3_text_search) @@ -224,7 +224,7 @@ function eql_v3.eq(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ function eql_v3.eq(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) function eql_v3.eq(a public.eql_v3_integer_ord_ore, b jsonb) function eql_v3.eq(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) -function eql_v3.eq(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry) +function eql_v3.eq(a public.eql_v3_json_entry, b public.eql_v3_json_entry) function eql_v3.eq(a public.eql_v3_numeric_eq, b eql_v3.query_numeric_eq) function eql_v3.eq(a public.eql_v3_numeric_eq, b jsonb) function eql_v3.eq(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) @@ -319,7 +319,7 @@ function eql_v3.eq_term(a public.eql_v3_text_ord_ore) function eql_v3.eq_term(a public.eql_v3_text_search) function eql_v3.eq_term(a public.eql_v3_text_search_ore) function eql_v3.eq_term(a public.eql_v3_timestamp_eq) -function eql_v3.eq_term(entry public.eql_v3_jsonb_entry) +function eql_v3.eq_term(entry public.eql_v3_json_entry) function eql_v3.gt(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) function eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) function eql_v3.gt(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) @@ -414,7 +414,7 @@ function eql_v3.gt(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ function eql_v3.gt(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) function eql_v3.gt(a public.eql_v3_integer_ord_ore, b jsonb) function eql_v3.gt(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) -function eql_v3.gt(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry) +function eql_v3.gt(a public.eql_v3_json_entry, b public.eql_v3_json_entry) function eql_v3.gt(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) function eql_v3.gt(a public.eql_v3_numeric_ord, b jsonb) function eql_v3.gt(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) @@ -560,7 +560,7 @@ function eql_v3.gte(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord function eql_v3.gte(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) function eql_v3.gte(a public.eql_v3_integer_ord_ore, b jsonb) function eql_v3.gte(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) -function eql_v3.gte(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry) +function eql_v3.gte(a public.eql_v3_json_entry, b public.eql_v3_json_entry) function eql_v3.gte(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) function eql_v3.gte(a public.eql_v3_numeric_ord, b jsonb) function eql_v3.gte(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) @@ -716,7 +716,7 @@ function eql_v3.lt(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ function eql_v3.lt(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) function eql_v3.lt(a public.eql_v3_integer_ord_ore, b jsonb) function eql_v3.lt(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) -function eql_v3.lt(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry) +function eql_v3.lt(a public.eql_v3_json_entry, b public.eql_v3_json_entry) function eql_v3.lt(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) function eql_v3.lt(a public.eql_v3_numeric_ord, b jsonb) function eql_v3.lt(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) @@ -862,7 +862,7 @@ function eql_v3.lte(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord function eql_v3.lte(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) function eql_v3.lte(a public.eql_v3_integer_ord_ore, b jsonb) function eql_v3.lte(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) -function eql_v3.lte(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry) +function eql_v3.lte(a public.eql_v3_json_entry, b public.eql_v3_json_entry) function eql_v3.lte(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) function eql_v3.lte(a public.eql_v3_numeric_ord, b jsonb) function eql_v3.lte(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) @@ -1045,7 +1045,7 @@ function eql_v3.neq(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord function eql_v3.neq(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) function eql_v3.neq(a public.eql_v3_integer_ord_ore, b jsonb) function eql_v3.neq(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) -function eql_v3.neq(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry) +function eql_v3.neq(a public.eql_v3_json_entry, b public.eql_v3_json_entry) function eql_v3.neq(a public.eql_v3_numeric_eq, b eql_v3.query_numeric_eq) function eql_v3.neq(a public.eql_v3_numeric_eq, b jsonb) function eql_v3.neq(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) @@ -1150,7 +1150,7 @@ function eql_v3.ord_term(a public.eql_v3_text_ord_ope) function eql_v3.ord_term(a public.eql_v3_text_search) function eql_v3.ord_term(a public.eql_v3_timestamp_ord) function eql_v3.ord_term(a public.eql_v3_timestamp_ord_ope) -function eql_v3.ord_term(entry public.eql_v3_jsonb_entry) +function eql_v3.ord_term(entry public.eql_v3_json_entry) function eql_v3.ord_term_ore(a eql_v3.query_bigint_ord_ore) function eql_v3.ord_term_ore(a eql_v3.query_date_ord_ore) function eql_v3.ord_term_ore(a eql_v3.query_double_ord_ore) @@ -1171,10 +1171,10 @@ function eql_v3.ord_term_ore(a public.eql_v3_smallint_ord_ore) function eql_v3.ord_term_ore(a public.eql_v3_text_ord_ore) function eql_v3.ord_term_ore(a public.eql_v3_text_search_ore) function eql_v3.ord_term_ore(a public.eql_v3_timestamp_ord_ore) -function eql_v3.selector(entry public.eql_v3_jsonb_entry) +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, b public.eql_v3_json) -function eql_v3.to_ste_vec_query(e public.eql_v3_json) +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 public.eql_v3_json_search) function eql_v3.version() diff --git a/tests/sqlx/src/fixtures/eql_plaintext.rs b/tests/sqlx/src/fixtures/eql_plaintext.rs index a00add49a..8cb3744ca 100644 --- a/tests/sqlx/src/fixtures/eql_plaintext.rs +++ b/tests/sqlx/src/fixtures/eql_plaintext.rs @@ -221,7 +221,7 @@ impl EqlPlaintext for String { /// /// `serde_json::Value` is the document analogue of the scalar plaintexts: /// `to_plaintext` lifts it into `Plaintext::Json`, which cipherstash-client -/// encrypts into a SteVec `public.eql_v3_json` payload under a JSON-indexed +/// encrypts into a SteVec `public.eql_v3_json_search` payload under a JSON-indexed /// `ColumnConfig` (`IndexKind::SteVec`). The `cast_for_kind` / /// `plaintext_sql_type_for_kind` derivations panic on `ScalarKind::Jsonb` /// (the scalar matrix never wires jsonb), so this impl OVERRIDES `CAST` and diff --git a/tests/sqlx/src/fixtures/v3_convert.rs b/tests/sqlx/src/fixtures/v3_convert.rs index 5e776bf50..f13c0eeb3 100644 --- a/tests/sqlx/src/fixtures/v3_convert.rs +++ b/tests/sqlx/src/fixtures/v3_convert.rs @@ -131,7 +131,7 @@ fn term_key_for(index: IndexKind) -> Option<&'static str> { /// the single `json` document target for [`ScalarKind::Jsonb`]. fn targets_for(kind: ScalarKind, indexes: &[IndexKind]) -> Result> { if kind == ScalarKind::Jsonb { - let target = TargetDomain::parse("eql_v3_json") + let target = TargetDomain::parse("eql_v3_json_search") .map_err(|e| anyhow!("resolving the SteVec document target: {e}"))?; return Ok(vec![target]); } diff --git a/tests/sqlx/src/fixtures/v3_doc_integer.rs b/tests/sqlx/src/fixtures/v3_doc_integer.rs index 00d807cea..15f944385 100644 --- a/tests/sqlx/src/fixtures/v3_doc_integer.rs +++ b/tests/sqlx/src/fixtures/v3_doc_integer.rs @@ -25,9 +25,9 @@ use super::spec::FixtureSpec; /// `v3_doc_integer.sql`, SQLx ref `scripts("v3_doc_integer")`. const NAME: &str = "v3_doc_integer"; -/// The generated `payload` column type — the `public.eql_v3_json` document DOMAIN, so +/// The generated `payload` column type — the `public.eql_v3_json_search` document DOMAIN, so /// the domain CHECK runs when the fixture loads. -const PAYLOAD_TYPE: &str = "public.eql_v3_json"; +const PAYLOAD_TYPE: &str = "public.eql_v3_json_search"; /// JSON path encrypted in each document. The SteVec selector hash for this /// path is pinned in `SELECTOR` below. diff --git a/tests/sqlx/src/fixtures/v3_ste_vec.rs b/tests/sqlx/src/fixtures/v3_ste_vec.rs index 1b09febd3..e3fc7be54 100644 --- a/tests/sqlx/src/fixtures/v3_ste_vec.rs +++ b/tests/sqlx/src/fixtures/v3_ste_vec.rs @@ -5,7 +5,7 @@ //! A `serde_json::Value` is a first-class `EqlPlaintext` (see //! `eql_plaintext.rs`), so the document fixture is just a //! `FixtureSpec` with the `IndexKind::SteVec` index and an -//! `public.eql_v3_json` generated `payload` column. `FixtureSpec::run` encrypts each +//! `public.eql_v3_json_search` generated `payload` column. `FixtureSpec::run` encrypts each //! document through cipherstash-client into a SteVec payload, stages it, and //! writes `tests/sqlx/fixtures/v3_ste_vec.sql` (gitignored — regenerated on //! every `mise run test:sqlx`) with the identical @@ -25,9 +25,9 @@ use super::spec::FixtureSpec; /// `v3_ste_vec.sql`, SQLx ref `scripts("v3_ste_vec")`. const NAME: &str = "v3_ste_vec"; -/// The canonical `payload` column type — the `public.eql_v3_json` DOMAIN, so the +/// The canonical `payload` column type — the `public.eql_v3_json_search` DOMAIN, so the /// domain CHECK runs when the fixture loads. -const PAYLOAD_TYPE: &str = "public.eql_v3_json"; +const PAYLOAD_TYPE: &str = "public.eql_v3_json_search"; /// Number of fixture rows. Ten matches the historical fixture and gives the /// harness's containment / index tests a non-trivial set. @@ -98,7 +98,7 @@ mod tests { .with_column_type(PAYLOAD_TYPE) .with_values(&docs); assert_eq!(spec.fixture_table(), "fixtures.v3_ste_vec"); - assert_eq!(spec.column_type().as_str(), "public.eql_v3_json"); + assert_eq!(spec.column_type().as_str(), "public.eql_v3_json_search"); assert_eq!(spec.indexes(), &[IndexKind::SteVec]); assert!(spec.check_complete().is_ok()); } diff --git a/tests/sqlx/src/fixtures/validation.rs b/tests/sqlx/src/fixtures/validation.rs index 0c903724f..87115de10 100644 --- a/tests/sqlx/src/fixtures/validation.rs +++ b/tests/sqlx/src/fixtures/validation.rs @@ -25,11 +25,11 @@ fn is_valid_identifier(s: &str) -> bool { } /// Allowlist of generated `payload` column types. `jsonb` for the scalar -/// fixtures; `public.eql_v3_json` for the v3 jsonb (SteVec document) fixture, whose -/// generated `payload` column is the `public.eql_v3_json` DOMAIN so the domain CHECK +/// fixtures; `public.eql_v3_json_search` for the v3 jsonb (SteVec document) fixture, whose +/// generated `payload` column is the `public.eql_v3_json_search` DOMAIN so the domain CHECK /// runs on load. Schema-qualified tokens are allowed — each is an exact, /// vetted entry here, never a free-form `&str`. -pub const ALLOWED_COLUMN_TYPES: &[&str] = &["jsonb", "public.eql_v3_json"]; +pub const ALLOWED_COLUMN_TYPES: &[&str] = &["jsonb", "public.eql_v3_json_search"]; fn is_valid_column_type(s: &str) -> bool { ALLOWED_COLUMN_TYPES.contains(&s) @@ -143,7 +143,7 @@ mod tests { #[test] fn column_type_accepts_allowlisted_tokens_only() { assert!(ColumnType::try_from("jsonb").is_ok()); - assert!(ColumnType::try_from("public.eql_v3_json").is_ok()); + assert!(ColumnType::try_from("public.eql_v3_json_search").is_ok()); assert!(ColumnType::try_from("text").is_err()); assert!(ColumnType::try_from("eql_v3_integer").is_err()); assert!(ColumnType::try_from("eql_v3.jsonb").is_err()); diff --git a/tests/sqlx/src/jsonb_entry.rs b/tests/sqlx/src/jsonb_entry.rs index 102aa89ed..5bb63f924 100644 --- a/tests/sqlx/src/jsonb_entry.rs +++ b/tests/sqlx/src/jsonb_entry.rs @@ -1,7 +1,7 @@ //! SteVec **entry** view type for the behaviour matrix. A `JsonbEntryInteger` //! reuses the `i32` plaintext oracle (`expected_forward`, pivots, //! `fixture_values`) but reaches its comparable value by extracting the entry -//! at `v3_doc_integer::SELECTOR` and casting to `public.eql_v3_jsonb_entry`, so the +//! at `v3_doc_integer::SELECTOR` and casting to `public.eql_v3_json_entry`, so the //! matrix's correctness/ordering/null/order-by/count/index generators run //! against jsonb-entry comparisons instead of whole-column scalar casts. //! @@ -64,13 +64,13 @@ impl ScalarType for JsonbEntryInteger { /// Single entry domain, variant-independent. fn sql_domain(_variant: Variant) -> String { - "public.eql_v3_jsonb_entry".to_string() + "public.eql_v3_json_entry".to_string() } /// Extract the entry at the pinned selector. `->` already yields - /// `public.eql_v3_jsonb_entry`; the call sites' `::public.eql_v3_jsonb_entry` cast is + /// `public.eql_v3_json_entry`; the call sites' `::public.eql_v3_json_entry` cast is /// a no-op. The selector literal is explicitly typed as text so Postgres - /// resolves the `public.eql_v3_json -> text` operator instead of native jsonb path + /// resolves the `public.eql_v3_json_search -> text` operator instead of native jsonb path /// lookup. Parenthesised by the call sites (`({col})::{d}`). fn column_expr() -> String { format!("payload -> '{}'::text", v3_doc_integer::SELECTOR) @@ -80,7 +80,7 @@ impl ScalarType for JsonbEntryInteger { value.0.to_string() } - /// Valid `public.eql_v3_jsonb_entry` literal for tests that only need a non-NULL + /// Valid `public.eql_v3_json_entry` literal for tests that only need a non-NULL /// operand shape (NULL propagation). Must satisfy the domain CHECK: string /// `s`, string `c`, exactly one of `hm`/`op`. fn placeholder_payload() -> &'static str { @@ -144,7 +144,7 @@ mod tests { ); assert_eq!( ::sql_domain(Variant::Ord), - "public.eql_v3_jsonb_entry", + "public.eql_v3_json_entry", ); assert_eq!( ::ord_extractor_expr(Variant::Ord, "value"), @@ -202,7 +202,7 @@ mod tests { assert_eq!(::mid_pivot().0, 0); } - /// The placeholder must satisfy the `public.eql_v3_jsonb_entry` CHECK shape: + /// The placeholder must satisfy the `public.eql_v3_json_entry` CHECK shape: /// string `s`, string `c`, exactly one of `hm`/`op`. (SQL-level validity is /// asserted in the integration `jsonb_entry` suite against the live domain.) #[test] diff --git a/tests/sqlx/src/matrix.rs b/tests/sqlx/src/matrix.rs index 7ea9f2417..aec851ca2 100644 --- a/tests/sqlx/src/matrix.rs +++ b/tests/sqlx/src/matrix.rs @@ -455,7 +455,7 @@ macro_rules! scalar_matrix { /// `JsonbEntryInteger`). Runs only the leaf drivers that are surface-agnostic /// once routed through the access-path seam: correctness (d,d only), /// supported_null, order_by(+nulls/+using), count, index_engages, and — once -/// `src/v3/jsonb/aggregates.sql` exists — aggregate(+group_by/+parallel). +/// `src/v3/json/aggregates.sql` exists — aggregate(+group_by/+parallel). /// Containment / blockers / payload_check / path-op / native-absent / /// planner-metadata stay in the hand-written `v3_jsonb_tests` suite — they have /// no scalar analogue or assert document-specific surface. @@ -516,7 +516,7 @@ macro_rules! jsonb_entry_matrix { // the entry operator. The hand-written `jsonb_entry_integer_index_engages` // test in the suite probes index engagement with the domain-cast RHS only. - // Aggregates: eql_v3.min/max over jsonb_entry (src/v3/jsonb/aggregates.sql). + // Aggregates: eql_v3.min/max over json_entry (src/v3/json/aggregates.sql). // The aggregate leaf cases compare extrema via the ord-extractor seam // (eql_v3.ord_term for entries), so the entry min/max route through the // `oc` (CLLW ORE) term exactly like the comparison operators. diff --git a/tests/sqlx/src/scalar_domains.rs b/tests/sqlx/src/scalar_domains.rs index 40a408f9f..f1bdc4576 100644 --- a/tests/sqlx/src/scalar_domains.rs +++ b/tests/sqlx/src/scalar_domains.rs @@ -137,7 +137,7 @@ pub trait ScalarType: /// SQL domain the comparable value is cast to. Default: the generated /// scalar domain `public.`. A non-scalar surface - /// (e.g. a SteVec entry, whose single domain `public.eql_v3_jsonb_entry` is + /// (e.g. a SteVec entry, whose single domain `public.eql_v3_json_entry` is /// variant-independent) overrides this to ignore the suffix. fn sql_domain(variant: Variant) -> String { format!("public.eql_v3_{}{}", Self::PG_TYPE, variant.suffix()) @@ -147,8 +147,8 @@ pub trait ScalarType: /// Default: the bare `payload` column (a whole encrypted-scalar payload). /// A SteVec-entry view overrides this with an extraction expression such /// as `(payload -> '')`, which already has type - /// `public.eql_v3_jsonb_entry`. The expression is cast to `sql_domain(variant)` - /// at every call site, so a redundant `::public.eql_v3_jsonb_entry` cast on an + /// `public.eql_v3_json_entry`. The expression is cast to `sql_domain(variant)` + /// at every call site, so a redundant `::public.eql_v3_json_entry` cast on an /// already-entry expression is a harmless no-op. fn column_expr() -> String { "payload".to_string() diff --git a/tests/sqlx/tests/build_validation_tests.rs b/tests/sqlx/tests/build_validation_tests.rs index cd5723f15..7c2f87a8c 100644 --- a/tests/sqlx/tests/build_validation_tests.rs +++ b/tests/sqlx/tests/build_validation_tests.rs @@ -59,7 +59,7 @@ fn v3_variant_omits_v2_coupled_pin_search_path() { // removed eql_v2-coupled tasks/pin_search_path.sql (which referenced // public.eql_v2_encrypted / eql_v2.ste_vec_entry and only pinned eql_v2 // functions). Match the eql_v2-QUALIFIED markers: a bare `ste_vec_entry` - // substring would false-positive on the legitimate `public.eql_v3_jsonb_entry` + // substring would false-positive on the legitimate `public.eql_v3_json_entry` // DOMAIN that the v3 jsonb document surface defines. let sql = read_release_sql("cipherstash-encrypt.sql"); assert!( diff --git a/tests/sqlx/tests/encrypted_domain/family/jsonb_check.rs b/tests/sqlx/tests/encrypted_domain/family/jsonb_check.rs index 5938e95fd..6e6da670f 100644 --- a/tests/sqlx/tests/encrypted_domain/family/jsonb_check.rs +++ b/tests/sqlx/tests/encrypted_domain/family/jsonb_check.rs @@ -1,7 +1,7 @@ //! Equivalence guards for the inline SteVec domain CHECK expressions //! (issue #354). //! -//! `public.eql_v3_jsonb_entry` carries an INLINE CHECK expression rather than +//! `public.eql_v3_json_entry` carries an INLINE CHECK expression rather than //! calling `public.eql_v3_is_valid_ste_vec_entry_payload`: domain //! constraints cannot inline SQL functions, so the function-call form paid //! the per-call SQL-function executor on every cast — the needle cast in @@ -12,11 +12,11 @@ //! divergence is SQL NULL, which both forms accept (the validator via //! STRICT, the inline expression via a leading `VALUE IS NULL OR`). //! -//! `eql_v3.query_jsonb`'s CHECK CANNOT be inlined — validating sv elements +//! `eql_v3.query_json`'s CHECK CANNOT be inlined — validating sv elements //! needs a subquery, which CHECK constraints forbid — so its validator is //! plpgsql instead (cached plan vs the per-call SQL-function executor; the -//! issue #353 finding). `query_jsonb_check_behaviour` characterises the -//! accept/reject matrix, and `query_jsonb_validator_is_plpgsql` guards the +//! issue #353 finding). `query_json_check_behaviour` characterises the +//! accept/reject matrix, and `query_json_validator_is_plpgsql` guards the //! language so a revert to LANGUAGE sql fails here. use anyhow::Result; @@ -94,7 +94,7 @@ async fn jsonb_entry_check_matches_validator(pool: PgPool) -> Result<()> { ]; assert_equivalent( &pool, - "public.eql_v3_jsonb_entry", + "public.eql_v3_json_entry", "eql_v3_is_valid_ste_vec_entry_payload", candidates, ) @@ -102,7 +102,7 @@ async fn jsonb_entry_check_matches_validator(pool: PgPool) -> Result<()> { } #[sqlx::test] -async fn query_jsonb_check_behaviour(pool: PgPool) -> Result<()> { +async fn query_json_check_behaviour(pool: PgPool) -> Result<()> { // (payload, expected accept) — hardcoded verdicts: the CHECK calls the // validator, so a validator-equivalence assertion would be tautological. let candidates: &[(Option<&str>, bool)] = &[ @@ -128,22 +128,178 @@ async fn query_jsonb_check_behaviour(pool: PgPool) -> Result<()> { (Some("[]"), false), ]; for (payload, expected) in candidates { - let cast = cast_accepts(&pool, "eql_v3.query_jsonb", *payload).await?; + let cast = cast_accepts(&pool, "eql_v3.query_json", *payload).await?; anyhow::ensure!( cast == *expected, - "eql_v3.query_jsonb cast verdict changed for {payload:?}: \ + "eql_v3.query_json cast verdict changed for {payload:?}: \ accepted = {cast}, expected = {expected}" ); } Ok(()) } -/// The query_jsonb validator must stay plpgsql: its only caller is the domain +/// Cast `payload` to the bare storage domain and observe whether its CHECK +/// accepts. Deliberately NOT the shared `cast_accepts` helper: that uses +/// `IS NOT DISTINCT FROM` (i.e. `=`), and `=` is a BLOCKED operator on the +/// storage domain (every comparison raises). `IS NOT NULL` needs no operator on +/// the domain, so it isolates the CHECK verdict. SQL NULL casts to NULL and +/// evaluates no CHECK, so it is accepted (Ok, no error). +async fn storage_cast_accepts(pool: &PgPool, payload: Option<&str>) -> Result { + let sql = "SELECT ($1::jsonb)::public.eql_v3_json IS NOT NULL"; + match sqlx::query_scalar::<_, bool>(sql) + .bind(payload) + .fetch_one(pool) + .await + { + Ok(_) => Ok(true), + Err(e) if e.to_string().contains("check constraint") => Ok(false), + Err(e) => Err(e.into()), + } +} + +/// The bare storage domain `public.eql_v3_json` (ciphertext-only encrypted +/// JSON) accepts only a well-formed `{v,i,c}` envelope at `v == '3'`, and in +/// particular REJECTS a SteVec document payload (`{v,i,sv}` with no root `c`) — +/// the structural distinction from the searchable `public.eql_v3_json_search`. +#[sqlx::test] +async fn json_storage_check_accepts_envelope_rejects_malformed(pool: PgPool) -> Result<()> { + let candidates: &[(Option<&str>, bool)] = &[ + // SQL NULL — a domain accepts NULL (no CHECK is evaluated). + (None, true), + // Valid: the minimal `{v,i,c}` envelope; extra keys allowed. + (Some(r#"{"v":"3","i":{},"c":"ct"}"#), true), + ( + Some(r#"{"v":"3","i":{"t":"tbl","c":"col"},"c":"ct","extra":1}"#), + true, + ), + // Invalid: a SteVec document (`sv`, no root `c`) — belongs to + // public.eql_v3_json_search, not the ciphertext-only storage domain. + ( + Some(r#"{"v":"3","i":{},"sv":[{"s":"sel","hm":"h"}]}"#), + false, + ), + // Invalid: missing c / missing v / missing i / wrong version. + (Some(r#"{"v":"3","i":{}}"#), false), + (Some(r#"{"i":{},"c":"ct"}"#), false), + (Some(r#"{"v":"3","c":"ct"}"#), false), + (Some(r#"{"v":"2","i":{},"c":"ct"}"#), false), + // Invalid: non-object roots. + (Some(r#""scalar""#), false), + (Some("5"), false), + (Some("null"), false), + (Some("[]"), false), + ]; + for (payload, expected) in candidates { + let cast = storage_cast_accepts(&pool, *payload).await?; + anyhow::ensure!( + cast == *expected, + "public.eql_v3_json cast verdict for {payload:?}: accepted = {cast}, \ + expected = {expected}" + ); + } + Ok(()) +} + +/// The comparison/containment native jsonb operators are BLOCKED on +/// `public.eql_v3_json`: a value typed as the storage domain can never fall +/// through to plaintext-jsonb equality/containment. Each raises +/// `... is not supported ...` (a LANGUAGE plpgsql blocker the planner cannot +/// elide). NB: the pure path/existence operators (`->`, `->>`, `?`) resolve to +/// native jsonb on ANY jsonb-backed storage domain (`eql_v3_integer` included) — +/// a pre-existing PostgreSQL operator-resolution quirk, not specific to `json` +/// — so they are deliberately not asserted here. +#[sqlx::test] +async fn json_storage_blocks_native_comparison_operators(pool: PgPool) -> Result<()> { + let envelope = r#"{"v":"3","i":{},"c":"ct"}"#; + let ops: &[&str] = &[ + "col = '{}'::jsonb", + "col @> '{}'::jsonb", + "col <@ '{}'::jsonb", + "col #> '{k}'::text[]", + "col || '{}'::jsonb", + ]; + for frag in ops { + let sql = format!("SELECT {frag} FROM (SELECT $1::public.eql_v3_json AS col) t"); + let err = sqlx::query_scalar::<_, serde_json::Value>(&sql) + .bind(envelope) + .fetch_one(&pool) + .await + .expect_err(&format!( + "native jsonb operator in `{frag}` must be blocked" + )); + anyhow::ensure!( + err.to_string().contains("is not supported"), + "expected a 'not supported' blocker error for `{frag}`, got: {err}" + ); + } + Ok(()) +} + +/// KNOWN LIMITATION (characterization test — pins current behaviour, there is no +/// fix). The pure path/existence native jsonb operators `->`, `->>`, and `?` are +/// NOT blocked on `public.eql_v3_json`: they resolve to the native `jsonb` +/// operator and return a plaintext result (`NULL` / `false`) instead of raising +/// the blocker. This is a PostgreSQL operator-resolution quirk affecting EVERY +/// jsonb-backed storage domain (`eql_v3_integer`, `eql_v3_boolean`, … — not +/// specific to `json`): for these operators the planner binds the base-type +/// `jsonb` operator rather than the domain-specific blocker. The +/// comparison/containment operators (`=`, `@>`, `<@`, `#>`, `||`) DO engage the +/// blocker — see `json_storage_blocks_native_comparison_operators`. +/// +/// The encrypted ciphertext lives in `c`, so `->'c'` / `->>'c'` merely echo the +/// already-opaque ciphertext string and `?` tests key presence in the envelope — +/// none of which leaks plaintext. This test exists so that if a future +/// PostgreSQL version (or an EQL change) starts routing these through the +/// blocker, the change is noticed here rather than silently altering behaviour. +#[sqlx::test] +async fn json_storage_path_operators_fall_through_to_native_known_limitation( + pool: PgPool, +) -> Result<()> { + let envelope = r#"{"v":"3","i":{},"c":"ct"}"#; + let of = |frag: &str| format!("SELECT {frag} FROM (SELECT $1::public.eql_v3_json AS col) t"); + + // `->` / `->>` return native jsonb: NULL for an absent key, and `-> 'c'` + // echoes the (already-opaque) ciphertext string — no plaintext leak. None raise. + let jsonb_cases: &[(&str, serde_json::Value)] = &[ + ("col -> 'missing'", serde_json::Value::Null), + ("col ->> 'missing'", serde_json::Value::Null), + ("col -> 'c'", serde_json::json!("ct")), + ]; + for (frag, expected) in jsonb_cases { + let got: Option = sqlx::query_scalar(&of(frag)) + .bind(envelope) + .fetch_one(&pool) + .await + .unwrap_or_else(|e| panic!("`{frag}` unexpectedly raised (limitation changed?): {e}")); + let got = got.unwrap_or(serde_json::Value::Null); + anyhow::ensure!( + &got == expected, + "path operator `{frag}` returned {got:?}, expected native {expected:?}" + ); + } + + // `?` tests envelope key presence and returns a native boolean (does not raise). + let key_cases: &[(&str, bool)] = &[("col ? 'c'", true), ("col ? 'absent'", false)]; + for (frag, expected) in key_cases { + let got: bool = sqlx::query_scalar(&of(frag)) + .bind(envelope) + .fetch_one(&pool) + .await + .unwrap_or_else(|e| panic!("`{frag}` unexpectedly raised (limitation changed?): {e}")); + anyhow::ensure!( + got == *expected, + "existence operator `{frag}` returned {got}, expected native {expected}" + ); + } + Ok(()) +} + +/// The query_json validator must stay plpgsql: its only caller is the domain /// CHECK (a context that can never inline a SQL function), so LANGUAGE sql /// pays the per-call SQL-function executor on every containment-needle cast /// (issues #353/#354). A revert fails here. #[sqlx::test] -async fn query_jsonb_validator_is_plpgsql(pool: PgPool) -> Result<()> { +async fn query_json_validator_is_plpgsql(pool: PgPool) -> Result<()> { let lang: String = sqlx::query_scalar( "SELECT l.lanname FROM pg_proc p \ JOIN pg_language l ON l.oid = p.prolang \ diff --git a/tests/sqlx/tests/encrypted_domain/family/support.rs b/tests/sqlx/tests/encrypted_domain/family/support.rs index a78de42be..5ee78e28d 100644 --- a/tests/sqlx/tests/encrypted_domain/family/support.rs +++ b/tests/sqlx/tests/encrypted_domain/family/support.rs @@ -156,17 +156,17 @@ async fn no_cross_variant_operator_is_declared(pool: PgPool) -> Result<()> { // `=`. If someone accidentally adds such an operator, this test fails. // // The jsonb DOCUMENT surface is excluded: it intentionally defines - // cross-type containment operators (`json @> query_jsonb`, + // cross-type containment operators (`json @> query_json`, // `json @> jsonb_entry` and their `<@` commutators) — the documented // document-containment API, not scalar capability variants that must - // resolve to a blocker. So `json` / `jsonb_entry` / `query_jsonb` are + // resolve to a blocker. So `json` / `jsonb_entry` / `query_json` are // out of scope for this scalar-variant guard. // // The check is structural (`pg_operator`) rather than dynamic // ("invoke and see it raise") so a future PG version with stricter // operator resolution doesn't mask the regression. // Derive the excluded (non-scalar) domain names from the catalog rather than - // hardcoding `'json', 'jsonb_entry', 'query_jsonb'` — a future rename or a + // hardcoding `'json', 'jsonb_entry', 'query_json'` — a future rename or a // second non-scalar family stays covered automatically (the names come from // the same `DomainFamily::domain_name` the SQL surface is generated through). let excluded: Vec = eql_domains::CATALOG diff --git a/tests/sqlx/tests/encrypted_domain/jsonb_entry.rs b/tests/sqlx/tests/encrypted_domain/jsonb_entry.rs index 9bfb209a0..cdf5bd61e 100644 --- a/tests/sqlx/tests/encrypted_domain/jsonb_entry.rs +++ b/tests/sqlx/tests/encrypted_domain/jsonb_entry.rs @@ -65,7 +65,7 @@ async fn jsonb_entry_integer_fixture_shape(pool: sqlx::PgPool) -> anyhow::Result let invalid: i64 = sqlx::query_scalar(&format!( "SELECT COUNT(*) FROM fixtures.v3_doc_integer \ WHERE NOT public.eql_v3_is_valid_ste_vec_entry_payload((payload -> '{SELECTOR}'::text)::jsonb) \ - OR eql_v3.ord_term((payload -> '{SELECTOR}'::text)::public.eql_v3_jsonb_entry) IS NULL", + OR eql_v3.ord_term((payload -> '{SELECTOR}'::text)::public.eql_v3_json_entry) IS NULL", )) .fetch_one(&pool) .await?; @@ -105,8 +105,8 @@ async fn jsonb_entry_integer_fixture_shape(pool: sqlx::PgPool) -> anyhow::Result #[sqlx::test(fixtures(path = "../../fixtures", scripts("v3_doc_integer")))] async fn jsonb_entry_integer_selector_matches_fixture(pool: sqlx::PgPool) -> anyhow::Result<()> { // The `$.field` CLLW-OPE entry is the sv element carrying `op`. Cast the - // `public.eql_v3_json` payload to bare jsonb FIRST so `-> 'sv'` is the native array - // accessor, not the custom `public.eql_v3_json -> text` selector-lookup operator. + // `public.eql_v3_json_search` payload to bare jsonb FIRST so `-> 'sv'` is the native array + // accessor, not the custom `public.eql_v3_json_search -> text` selector-lookup operator. let live: Vec = sqlx::query_scalar( "SELECT DISTINCT elem ->> 's' \ FROM fixtures.v3_doc_integer, \ @@ -145,8 +145,8 @@ async fn jsonb_entry_integer_ord_ope_injectivity(pool: sqlx::PgPool) -> anyhow:: FROM fixtures.v3_doc_integer a \ JOIN fixtures.v3_doc_integer b ON a.id < b.id \ WHERE a.plaintext <> b.plaintext \ - AND eql_v3.ord_term((a.payload -> '{SELECTOR}'::text)::public.eql_v3_jsonb_entry) \ - = eql_v3.ord_term((b.payload -> '{SELECTOR}'::text)::public.eql_v3_jsonb_entry)", + AND eql_v3.ord_term((a.payload -> '{SELECTOR}'::text)::public.eql_v3_json_entry) \ + = eql_v3.ord_term((b.payload -> '{SELECTOR}'::text)::public.eql_v3_json_entry)", )) .fetch_one(&pool) .await?; @@ -162,7 +162,7 @@ async fn jsonb_entry_integer_ord_ope_injectivity(pool: sqlx::PgPool) -> anyhow:: // driver, which sweeps a bare-jsonb RHS that flattens to native `jsonb < jsonb` // for entries). Builds the ord_term functional btree and asserts each ORDERING // op (which inlines to `ord_term(value) ord_term(const)`) engages it, using -// the domain-cast RHS (`''::public.eql_v3_jsonb_entry`) so the entry operator +// the domain-cast RHS (`''::public.eql_v3_json_entry`) so the entry operator // resolves rather than native jsonb. // // VALIDITY ONLY: forces `enable_seqscan = off` on the ~17-row fixture, so a @@ -180,12 +180,12 @@ async fn jsonb_entry_integer_index_engages(pool: sqlx::PgPool) -> anyhow::Result let lit = payload.replace('\'', "''"); let mut tx = pool.begin().await?; - sqlx::query("CREATE TEMP TABLE entry_idx (value public.eql_v3_jsonb_entry) ON COMMIT DROP") + sqlx::query("CREATE TEMP TABLE entry_idx (value public.eql_v3_json_entry) ON COMMIT DROP") .execute(&mut *tx) .await?; sqlx::query(&format!( "INSERT INTO entry_idx(value) \ - SELECT (payload -> '{sel}'::text)::public.eql_v3_jsonb_entry FROM fixtures.v3_doc_integer", + SELECT (payload -> '{sel}'::text)::public.eql_v3_json_entry FROM fixtures.v3_doc_integer", )) .execute(&mut *tx) .await?; @@ -199,7 +199,7 @@ async fn jsonb_entry_integer_index_engages(pool: sqlx::PgPool) -> anyhow::Result for op in ["<", "<=", ">", ">="] { let query = - format!("SELECT * FROM entry_idx WHERE value {op} '{lit}'::public.eql_v3_jsonb_entry",); + format!("SELECT * FROM entry_idx WHERE value {op} '{lit}'::public.eql_v3_json_entry",); eql_tests::matrix::assert_index_scan_uses( &mut *tx, &query, @@ -229,7 +229,7 @@ async fn jsonb_entry_integer_aggregate_ignores_op_less_entries( pool: sqlx::PgPool, ) -> anyhow::Result<()> { let sel = SELECTOR; - // A valid public.eql_v3_jsonb_entry that is NOT orderable: string s, string c, + // A valid public.eql_v3_json_entry that is NOT orderable: string s, string c, // exactly one of hm/op — here `hm`, so `eql_v3.ord_term(entry)` is NULL. let op_less = r#"{"s":"forged","c":"x","hm":"00"}"#; @@ -242,18 +242,18 @@ async fn jsonb_entry_integer_aggregate_ignores_op_less_entries( let high = *sorted.last().expect("fixture is non-empty"); let mut tx = pool.begin().await?; - sqlx::query("CREATE TEMP TABLE op_mix (value public.eql_v3_jsonb_entry) ON COMMIT DROP") + sqlx::query("CREATE TEMP TABLE op_mix (value public.eql_v3_json_entry) ON COMMIT DROP") .execute(&mut *tx) .await?; // SEED position: the op-less entry is inserted FIRST, so the STRICT seed is // non-orderable — the exact case the sfunc guard must survive. - sqlx::query("INSERT INTO op_mix(value) VALUES ($1::jsonb::public.eql_v3_jsonb_entry)") + sqlx::query("INSERT INTO op_mix(value) VALUES ($1::jsonb::public.eql_v3_json_entry)") .bind(op_less) .execute(&mut *tx) .await?; sqlx::query(&format!( "INSERT INTO op_mix(value) \ - SELECT (payload -> '{sel}'::text)::public.eql_v3_jsonb_entry \ + SELECT (payload -> '{sel}'::text)::public.eql_v3_json_entry \ FROM fixtures.v3_doc_integer WHERE plaintext IN ({low}, {high})", )) .execute(&mut *tx) @@ -262,13 +262,13 @@ async fn jsonb_entry_integer_aggregate_ignores_op_less_entries( // Expected extrema: the orderable entries for the smallest / largest integer, // NOT the op-less seed. let expect_min: String = sqlx::query_scalar(&format!( - "SELECT ((payload -> '{sel}'::text)::public.eql_v3_jsonb_entry)::text \ + "SELECT ((payload -> '{sel}'::text)::public.eql_v3_json_entry)::text \ FROM fixtures.v3_doc_integer WHERE plaintext = {low}", )) .fetch_one(&mut *tx) .await?; let expect_max: String = sqlx::query_scalar(&format!( - "SELECT ((payload -> '{sel}'::text)::public.eql_v3_jsonb_entry)::text \ + "SELECT ((payload -> '{sel}'::text)::public.eql_v3_json_entry)::text \ FROM fixtures.v3_doc_integer WHERE plaintext = {high}", )) .fetch_one(&mut *tx) diff --git a/tests/sqlx/tests/payload_schema_tests.rs b/tests/sqlx/tests/payload_schema_tests.rs index 91c5589a1..45258ee8c 100644 --- a/tests/sqlx/tests/payload_schema_tests.rs +++ b/tests/sqlx/tests/payload_schema_tests.rs @@ -586,7 +586,7 @@ fn from_v2_ste_vec_output_validates_against_published_v3_schema() { { "s": SELECTOR, "a": true, "c": CIPHERTEXT, "op": HEX_LONG } ] }); - assert_converts_to_valid_v3(&v2, "eql_v3_json"); + assert_converts_to_valid_v3(&v2, "eql_v3_json_search"); } #[test] @@ -600,9 +600,9 @@ fn from_v2_query_output_validates_against_published_v3_schema() { }); let out = from_v2_query(&v2, TargetDomain::Json).expect("query conversion must succeed"); assert_valid( - &load_v3_schema("query_jsonb"), + &load_v3_schema("query_json"), &out, - "from_v2_query output for query_jsonb", + "from_v2_query output for query_json", ); } @@ -617,7 +617,7 @@ fn published_v3_schemas_reject_the_unconverted_v2_payloads() { "raw v2 ct payload", ); assert_invalid( - &load_v3_schema("eql_v3_json"), + &load_v3_schema("eql_v3_json_search"), &json!({ "v": 2, "k": "sv", "i": ident(), "sv": [{ "s": SELECTOR, "c": CIPHERTEXT, "hm": HEX }] diff --git a/tests/sqlx/tests/v3_jsonb_bindings_tests.rs b/tests/sqlx/tests/v3_jsonb_bindings_tests.rs index 5c20cde91..f9ef56d5c 100644 --- a/tests/sqlx/tests/v3_jsonb_bindings_tests.rs +++ b/tests/sqlx/tests/v3_jsonb_bindings_tests.rs @@ -2,13 +2,13 @@ //! the one test that ties eql-bindings to real cipherstash crypto AND to the //! hand-written src/v3/jsonb/types.sql domain CHECK simultaneously. //! -//! The fixture (`fixtures.v3_ste_vec`, column `payload public.eql_v3_json`) is GENERATED +//! The fixture (`fixtures.v3_ste_vec`, column `payload public.eql_v3_json_search`) is GENERATED //! by encrypting JSON documents through cipherstash-client's SteVec pipeline //! (`mise run fixture:generate:all`), so this exercises the bindings against the //! same wire shape the domain CHECK (`is_valid_ste_vec_document_payload`) //! validated at INSERT — not a hand-written literal. -use eql_bindings::v3::jsonb::{SteVecDocument, SteVecEntry, SteVecQuery, SteVecTerm}; +use eql_bindings::v3::json::{SteVecDocument, SteVecEntry, SteVecQuery, SteVecTerm}; use sqlx::PgPool; #[sqlx::test(fixtures(path = "../fixtures", scripts("v3_ste_vec")))] @@ -65,7 +65,7 @@ async fn real_ste_vec_row_parses_into_document_and_entries(pool: PgPool) -> anyh #[sqlx::test(fixtures(path = "../fixtures", scripts("v3_ste_vec")))] async fn real_ste_vec_query_parses_into_bindings(pool: PgPool) -> anyhow::Result<()> { // `eql_v3.to_ste_vec_query` turns an encrypted document into a containment - // needle (`eql_v3.query_jsonb`), the shape a caller builds a `@>` / `<@` + // needle (`eql_v3.query_json`), the shape a caller builds a `@>` / `<@` // query from. Parse a REAL one into `SteVecQuery` (and, transitively, its // `SteVecQueryEntry` elements), tying those two bindings to real crypto and // the hand-written `is_valid_ste_vec_query_payload` CHECK — the document/entry diff --git a/tests/sqlx/tests/v3_jsonb_operator_surface_tests.rs b/tests/sqlx/tests/v3_jsonb_operator_surface_tests.rs index ea9ec4927..e81d10786 100644 --- a/tests/sqlx/tests/v3_jsonb_operator_surface_tests.rs +++ b/tests/sqlx/tests/v3_jsonb_operator_surface_tests.rs @@ -4,12 +4,12 @@ //! This binary reads `pg_operator`, not the fixture. It verifies BOTH sides of //! the surface: //! 1. Every native jsonb operator symbol is either a supported root symbol OR -//! has an `public.eql_v3_json`-bound blocker (so a column can never silently route +//! has an `public.eql_v3_json_search`-bound blocker (so a column can never silently route //! to plaintext-jsonb semantics). //! 2. Every supported symbol is bound with EXACTLY the intended safe operand //! signatures, and unsupported root-document comparison signatures -//! (`public.eql_v3_json = public.eql_v3_json`, etc.) are blocked. -//! 3. Every blocker is bound to `public.eql_v3_json` with PostgreSQL's real native +//! (`public.eql_v3_json_search = public.eql_v3_json_search`, etc.) are blocked. +//! 3. Every blocker is bound to `public.eql_v3_json_search` with PostgreSQL's real native //! RHS type for that operator. //! //! Design source of truth: @@ -18,11 +18,11 @@ use sqlx::PgPool; use std::collections::BTreeSet; -/// Root-document operator symbols the surface SUPPORTS (an `public.eql_v3_json`-bound +/// Root-document operator symbols the surface SUPPORTS (an `public.eql_v3_json_search`-bound /// operator, not a blocker). const SUPPORTED_ROOT_SYMBOLS: &[&str] = &["@>", "<@", "->", "->>"]; -/// Entry comparison symbols on `public.eql_v3_jsonb_entry`. +/// Entry comparison symbols on `public.eql_v3_json_entry`. const SUPPORTED_ENTRY_SYMBOLS: &[&str] = &["=", "<>", "<", "<=", ">", ">="]; /// Native jsonb operators the surface BLOCKS (each raises "is not supported"). @@ -36,9 +36,9 @@ async fn v3_jsonb_operators(pool: &PgPool) -> anyhow::Result = sqlx::query_as( r#" WITH d AS ( - SELECT 'public.eql_v3_json'::regtype AS j, - 'public.eql_v3_jsonb_entry'::regtype AS e, - 'eql_v3.query_jsonb'::regtype AS q + SELECT 'public.eql_v3_json_search'::regtype AS j, + 'public.eql_v3_json_entry'::regtype AS e, + 'eql_v3.query_json'::regtype AS q ) SELECT o.oprname, pg_catalog.format_type(o.oprleft, NULL) AS lhs, @@ -54,16 +54,16 @@ async fn v3_jsonb_operators(pool: &PgPool) -> anyhow::Result String { match ty { - "eql_v3_json" => "public.eql_v3_json".to_string(), - "eql_v3_jsonb_entry" => "public.eql_v3_jsonb_entry".to_string(), + "eql_v3_json_search" => "public.eql_v3_json_search".to_string(), + "eql_v3_json_entry" => "public.eql_v3_json_entry".to_string(), // Qualified today (eql_v3 is off the default search_path); mapped // anyway so the assertions survive a search_path change. - "query_jsonb" => "eql_v3.query_jsonb".to_string(), + "query_json" => "eql_v3.query_json".to_string(), other => other.to_string(), } } @@ -90,11 +90,13 @@ async fn v3_jsonb_surface_supported_or_blocked(pool: PgPool) -> anyhow::Result<( "expected pg_operator to expose jsonb operators" ); - // The blocked symbols MUST each have an public.eql_v3_json-bound operator. + // The blocked symbols MUST each have an public.eql_v3_json_search-bound operator. let bound: Vec<(String, String, String)> = v3_jsonb_operators(&pool).await?; let json_bound_symbols: BTreeSet = bound .iter() - .filter(|(_, l, r)| norm(l) == "public.eql_v3_json" || norm(r) == "public.eql_v3_json") + .filter(|(_, l, r)| { + norm(l) == "public.eql_v3_json_search" || norm(r) == "public.eql_v3_json_search" + }) .map(|(n, _, _)| n.clone()) .collect(); @@ -113,9 +115,9 @@ async fn v3_jsonb_surface_supported_or_blocked(pool: PgPool) -> anyhow::Result<( assert!( unaccounted.is_empty(), "native jsonb operator(s) neither supported, blocked, nor an intentionally-native \ - comparison on public.eql_v3_json: {unaccounted:#?}. Each would route an encrypted column \ + comparison on public.eql_v3_json_search: {unaccounted:#?}. Each would route an encrypted column \ to native plaintext-jsonb semantics (e.g. key/path extraction). Add a supported \ - wrapper or an public.eql_v3_json-bound blocker." + wrapper or an public.eql_v3_json_search-bound blocker." ); // And every blocked symbol must actually be bound (no missing blocker). @@ -127,7 +129,7 @@ async fn v3_jsonb_surface_supported_or_blocked(pool: PgPool) -> anyhow::Result<( } assert!( missing_blockers.is_empty(), - "blocked symbol(s) have no public.eql_v3_json-bound operator: {missing_blockers:?}" + "blocked symbol(s) have no public.eql_v3_json_search-bound operator: {missing_blockers:?}" ); Ok(()) } @@ -147,47 +149,39 @@ async fn v3_jsonb_surface_supported_signatures(pool: PgPool) -> anyhow::Result<( // Exact supported operand signatures (verified against operators.sql). let expected_supported: &[(&str, &str, &str)] = &[ // containment - ("@>", "public.eql_v3_json", "public.eql_v3_json"), - ("@>", "public.eql_v3_json", "eql_v3.query_jsonb"), - ("@>", "public.eql_v3_json", "public.eql_v3_jsonb_entry"), - ("<@", "public.eql_v3_json", "public.eql_v3_json"), - ("<@", "eql_v3.query_jsonb", "public.eql_v3_json"), - ("<@", "public.eql_v3_jsonb_entry", "public.eql_v3_json"), - // path access - ("->", "public.eql_v3_json", "text"), - ("->", "public.eql_v3_json", "integer"), - ("->>", "public.eql_v3_json", "text"), - // entry comparisons - ( - "=", - "public.eql_v3_jsonb_entry", - "public.eql_v3_jsonb_entry", - ), - ( - "<>", - "public.eql_v3_jsonb_entry", - "public.eql_v3_jsonb_entry", - ), ( - "<", - "public.eql_v3_jsonb_entry", - "public.eql_v3_jsonb_entry", + "@>", + "public.eql_v3_json_search", + "public.eql_v3_json_search", ), + ("@>", "public.eql_v3_json_search", "eql_v3.query_json"), ( - "<=", - "public.eql_v3_jsonb_entry", - "public.eql_v3_jsonb_entry", + "@>", + "public.eql_v3_json_search", + "public.eql_v3_json_entry", ), ( - ">", - "public.eql_v3_jsonb_entry", - "public.eql_v3_jsonb_entry", + "<@", + "public.eql_v3_json_search", + "public.eql_v3_json_search", ), + ("<@", "eql_v3.query_json", "public.eql_v3_json_search"), ( - ">=", - "public.eql_v3_jsonb_entry", - "public.eql_v3_jsonb_entry", + "<@", + "public.eql_v3_json_entry", + "public.eql_v3_json_search", ), + // path access + ("->", "public.eql_v3_json_search", "text"), + ("->", "public.eql_v3_json_search", "integer"), + ("->>", "public.eql_v3_json_search", "text"), + // entry comparisons + ("=", "public.eql_v3_json_entry", "public.eql_v3_json_entry"), + ("<>", "public.eql_v3_json_entry", "public.eql_v3_json_entry"), + ("<", "public.eql_v3_json_entry", "public.eql_v3_json_entry"), + ("<=", "public.eql_v3_json_entry", "public.eql_v3_json_entry"), + (">", "public.eql_v3_json_entry", "public.eql_v3_json_entry"), + (">=", "public.eql_v3_json_entry", "public.eql_v3_json_entry"), ]; let mut missing: Vec<(&str, &str, &str)> = Vec::new(); @@ -216,7 +210,7 @@ async fn v3_jsonb_surface_root_comparisons_blocked(pool: PgPool) -> anyhow::Resu pg_catalog.format_type(o.oprright, NULL) FROM pg_operator o WHERE o.oprname IN ('=', '<>', '<', '<=', '>', '>=') - AND ('public.eql_v3_json'::regtype IN (o.oprleft, o.oprright)) + AND ('public.eql_v3_json_search'::regtype IN (o.oprleft, o.oprright)) ORDER BY 1, 2, 3 "#, ) @@ -228,9 +222,9 @@ async fn v3_jsonb_surface_root_comparisons_blocked(pool: PgPool) -> anyhow::Resu .collect(); for op in ["=", "<>", "<", "<=", ">", ">="] { for (l, r) in [ - ("public.eql_v3_json", "public.eql_v3_json"), - ("public.eql_v3_json", "jsonb"), - ("jsonb", "public.eql_v3_json"), + ("public.eql_v3_json_search", "public.eql_v3_json_search"), + ("public.eql_v3_json_search", "jsonb"), + ("jsonb", "public.eql_v3_json_search"), ] { assert!( have.contains(&(op.to_string(), l.to_string(), r.to_string())), @@ -259,9 +253,9 @@ async fn v3_jsonb_surface_entry_mixed_shapes_absent(pool: PgPool) -> anyhow::Res pg_catalog.format_type(o.oprright, NULL) FROM pg_operator o WHERE o.oprname IN ('=', '<>', '<', '<=', '>', '>=') - AND ('public.eql_v3_jsonb_entry'::regtype IN (o.oprleft, o.oprright)) - AND NOT (o.oprleft = 'public.eql_v3_jsonb_entry'::regtype - AND o.oprright = 'public.eql_v3_jsonb_entry'::regtype) + AND ('public.eql_v3_json_entry'::regtype IN (o.oprleft, o.oprright)) + AND NOT (o.oprleft = 'public.eql_v3_json_entry'::regtype + AND o.oprright = 'public.eql_v3_json_entry'::regtype) "#, ) .fetch_all(&pool) @@ -277,8 +271,8 @@ async fn v3_jsonb_surface_entry_mixed_shapes_absent(pool: PgPool) -> anyhow::Res r#" SELECT o.oprname FROM pg_operator o - WHERE o.oprleft = 'public.eql_v3_jsonb_entry'::regtype - AND o.oprright = 'public.eql_v3_jsonb_entry'::regtype + WHERE o.oprleft = 'public.eql_v3_json_entry'::regtype + AND o.oprright = 'public.eql_v3_json_entry'::regtype "#, ) .fetch_all(&pool) @@ -295,7 +289,7 @@ async fn v3_jsonb_surface_entry_mixed_shapes_absent(pool: PgPool) -> anyhow::Res } // ============================================================================ -// (3) Each blocker is bound to public.eql_v3_json with PostgreSQL's real native RHS +// (3) Each blocker is bound to public.eql_v3_json_search with PostgreSQL's real native RHS // type for that operator. // ============================================================================ @@ -310,45 +304,69 @@ async fn v3_jsonb_surface_blocker_signatures(pool: PgPool) -> anyhow::Result<()> // Exact blocker operand signatures with PostgreSQL's real native RHS types // (verified against blockers.sql and the live catalog). let expected_blockers: &[(&str, &str, &str)] = &[ - ("?", "public.eql_v3_json", "text"), - ("?|", "public.eql_v3_json", "text[]"), - ("?&", "public.eql_v3_json", "text[]"), - ("@?", "public.eql_v3_json", "jsonpath"), - ("@@", "public.eql_v3_json", "jsonpath"), - ("#>", "public.eql_v3_json", "text[]"), - ("#>>", "public.eql_v3_json", "text[]"), - ("-", "public.eql_v3_json", "text"), - ("-", "public.eql_v3_json", "integer"), - ("-", "public.eql_v3_json", "text[]"), - ("#-", "public.eql_v3_json", "text[]"), - ("||", "public.eql_v3_json", "jsonb"), + ("?", "public.eql_v3_json_search", "text"), + ("?|", "public.eql_v3_json_search", "text[]"), + ("?&", "public.eql_v3_json_search", "text[]"), + ("@?", "public.eql_v3_json_search", "jsonpath"), + ("@@", "public.eql_v3_json_search", "jsonpath"), + ("#>", "public.eql_v3_json_search", "text[]"), + ("#>>", "public.eql_v3_json_search", "text[]"), + ("-", "public.eql_v3_json_search", "text"), + ("-", "public.eql_v3_json_search", "integer"), + ("-", "public.eql_v3_json_search", "text[]"), + ("#-", "public.eql_v3_json_search", "text[]"), + ("||", "public.eql_v3_json_search", "jsonb"), // concat is also blocked with the domain on the RIGHT. - ("||", "jsonb", "public.eql_v3_json"), + ("||", "jsonb", "public.eql_v3_json_search"), // root comparisons are blocked for every typed domain/jsonb shape. - ("=", "public.eql_v3_json", "public.eql_v3_json"), - ("=", "public.eql_v3_json", "jsonb"), - ("=", "jsonb", "public.eql_v3_json"), - ("<>", "public.eql_v3_json", "public.eql_v3_json"), - ("<>", "public.eql_v3_json", "jsonb"), - ("<>", "jsonb", "public.eql_v3_json"), - ("<", "public.eql_v3_json", "public.eql_v3_json"), - ("<", "public.eql_v3_json", "jsonb"), - ("<", "jsonb", "public.eql_v3_json"), - ("<=", "public.eql_v3_json", "public.eql_v3_json"), - ("<=", "public.eql_v3_json", "jsonb"), - ("<=", "jsonb", "public.eql_v3_json"), - (">", "public.eql_v3_json", "public.eql_v3_json"), - (">", "public.eql_v3_json", "jsonb"), - (">", "jsonb", "public.eql_v3_json"), - (">=", "public.eql_v3_json", "public.eql_v3_json"), - (">=", "public.eql_v3_json", "jsonb"), - (">=", "jsonb", "public.eql_v3_json"), + ( + "=", + "public.eql_v3_json_search", + "public.eql_v3_json_search", + ), + ("=", "public.eql_v3_json_search", "jsonb"), + ("=", "jsonb", "public.eql_v3_json_search"), + ( + "<>", + "public.eql_v3_json_search", + "public.eql_v3_json_search", + ), + ("<>", "public.eql_v3_json_search", "jsonb"), + ("<>", "jsonb", "public.eql_v3_json_search"), + ( + "<", + "public.eql_v3_json_search", + "public.eql_v3_json_search", + ), + ("<", "public.eql_v3_json_search", "jsonb"), + ("<", "jsonb", "public.eql_v3_json_search"), + ( + "<=", + "public.eql_v3_json_search", + "public.eql_v3_json_search", + ), + ("<=", "public.eql_v3_json_search", "jsonb"), + ("<=", "jsonb", "public.eql_v3_json_search"), + ( + ">", + "public.eql_v3_json_search", + "public.eql_v3_json_search", + ), + (">", "public.eql_v3_json_search", "jsonb"), + (">", "jsonb", "public.eql_v3_json_search"), + ( + ">=", + "public.eql_v3_json_search", + "public.eql_v3_json_search", + ), + (">=", "public.eql_v3_json_search", "jsonb"), + (">=", "jsonb", "public.eql_v3_json_search"), // mixed jsonb containment shapes are blocked; safe forms use json, - // query_jsonb, or jsonb_entry. - ("@>", "public.eql_v3_json", "jsonb"), - ("@>", "jsonb", "public.eql_v3_json"), - ("<@", "public.eql_v3_json", "jsonb"), - ("<@", "jsonb", "public.eql_v3_json"), + // query_json, or jsonb_entry. + ("@>", "public.eql_v3_json_search", "jsonb"), + ("@>", "jsonb", "public.eql_v3_json_search"), + ("<@", "public.eql_v3_json_search", "jsonb"), + ("<@", "jsonb", "public.eql_v3_json_search"), ]; let mut missing: Vec<(&str, &str, &str)> = Vec::new(); @@ -362,7 +380,7 @@ async fn v3_jsonb_surface_blocker_signatures(pool: PgPool) -> anyhow::Result<()> "expected blocker signature(s) are absent: {missing:#?}" ); - // Every blocked symbol's public.eql_v3_json-bound operator backs a non-STRICT + // Every blocked symbol's public.eql_v3_json_search-bound operator backs a non-STRICT // plpgsql blocker function (proisstrict = false), so a NULL domain operand // still raises rather than short-circuiting to NULL. let strict_offenders: Vec<(String, String)> = sqlx::query_as( @@ -370,7 +388,7 @@ async fn v3_jsonb_surface_blocker_signatures(pool: PgPool) -> anyhow::Result<()> SELECT o.oprname, p.proname FROM pg_operator o JOIN pg_proc p ON p.oid = o.oprcode - WHERE ('public.eql_v3_json'::regtype IN (o.oprleft, o.oprright)) + WHERE ('public.eql_v3_json_search'::regtype IN (o.oprleft, o.oprright)) AND o.oprname IN ('?', '?|', '?&', '@?', '@@', '#>', '#>>', '-', '#-', '||', '=', '<>', '<', '<=', '>', '>=', '@>', '<@') AND p.proname LIKE 'jsonb_blocked%' @@ -481,8 +499,8 @@ async fn assert_composed_blocked(pool: &PgPool, sql: &str) -> anyhow::Result<()> #[sqlx::test] async fn v3_jsonb_blocked_composed_expression_raises(pool: PgPool) -> anyhow::Result<()> { - // A valid public.eql_v3_json document literal (empty sv array satisfies the CHECK). - let j = r#"'{"i":{},"v":3,"sv":[]}'::public.eql_v3_json"#; + // A valid public.eql_v3_json_search document literal (empty sv array satisfies the CHECK). + let j = r#"'{"i":{},"v":3,"sv":[]}'::public.eql_v3_json_search"#; // Each case wraps a blocked operator (whose return type was boolean before // the fix) in a surrounding operator that only resolves against the NATIVE diff --git a/tests/sqlx/tests/v3_jsonb_tests.rs b/tests/sqlx/tests/v3_jsonb_tests.rs index ab59b71c0..bfbbfa595 100644 --- a/tests/sqlx/tests/v3_jsonb_tests.rs +++ b/tests/sqlx/tests/v3_jsonb_tests.rs @@ -1,5 +1,5 @@ //! Parameterized test harness for the `eql_v3` encrypted-JSONB (SteVec) surface -//! (`public.eql_v3_json` / `public.eql_v3_jsonb_entry` / `eql_v3.query_jsonb`). +//! (`public.eql_v3_json_search` / `public.eql_v3_json_entry` / `eql_v3.query_json`). //! //! Design source of truth: //! `docs/superpowers/plans/2026-06-09-eql-v3-jsonb-test-harness-design.md`. @@ -10,7 +10,7 @@ //! `{scalar type}`, because a SteVec value is a *document* (a collection of //! leaves addressed by selector), so it does not fit `scalar_matrix!`. //! -//! CRITICAL correctness rule: `public.eql_v3_json` is a DOMAIN over `jsonb`. +//! CRITICAL correctness rule: `public.eql_v3_json_search` is a DOMAIN over `jsonb`. //! PostgreSQL resolves `domain OP untyped_literal` to the NATIVE jsonb operator //! (the domain flattens to its base type for unknown-typed literals). So every //! `->`/`->>` selector operand and every blocker RHS operand below is @@ -94,7 +94,7 @@ fn op_entry(op_hex: &str) -> String { entry(SEL_HELLO_OP, "op", op_hex) } -/// Build a document literal (`public.eql_v3_json`-shaped) wrapping the given sv element +/// Build a document literal (`public.eql_v3_json_search`-shaped) wrapping the given sv element /// literals (each already a JSON object string). fn doc(elems: &[String]) -> String { format!( @@ -103,7 +103,7 @@ fn doc(elems: &[String]) -> String { ) } -/// Build a `query_jsonb` needle literal from `(selector, term_field, hex)` +/// Build a `query_json` needle literal from `(selector, term_field, hex)` /// triples (each element carries `s` + exactly one term, never `c`). fn needle(elems: &[(&str, &str, &str)]) -> String { let parts: Vec = elems @@ -147,23 +147,23 @@ macro_rules! v3_jsonb_eq_correctness { // = is true iff terms equal. let eq_same: bool = sqlx::query_scalar(&format!( - "SELECT '{same_a}'::public.eql_v3_jsonb_entry = '{same_b}'::public.eql_v3_jsonb_entry" + "SELECT '{same_a}'::public.eql_v3_json_entry = '{same_b}'::public.eql_v3_json_entry" )).fetch_one(&pool).await?; assert!(eq_same, "{} entries with equal terms must be =", $field); let eq_diff: bool = sqlx::query_scalar(&format!( - "SELECT '{same_a}'::public.eql_v3_jsonb_entry = '{diff_b}'::public.eql_v3_jsonb_entry" + "SELECT '{same_a}'::public.eql_v3_json_entry = '{diff_b}'::public.eql_v3_json_entry" )).fetch_one(&pool).await?; assert!(!eq_diff, "{} entries with differing terms must NOT be =", $field); // <> is the exact negation of =. let neq_same: bool = sqlx::query_scalar(&format!( - "SELECT '{same_a}'::public.eql_v3_jsonb_entry <> '{same_b}'::public.eql_v3_jsonb_entry" + "SELECT '{same_a}'::public.eql_v3_json_entry <> '{same_b}'::public.eql_v3_json_entry" )).fetch_one(&pool).await?; assert!(!neq_same, "<> must be false when terms equal"); let neq_diff: bool = sqlx::query_scalar(&format!( - "SELECT '{same_a}'::public.eql_v3_jsonb_entry <> '{diff_b}'::public.eql_v3_jsonb_entry" + "SELECT '{same_a}'::public.eql_v3_json_entry <> '{diff_b}'::public.eql_v3_json_entry" )).fetch_one(&pool).await?; assert!(neq_diff, "<> must be true when terms differ"); @@ -202,21 +202,21 @@ macro_rules! v3_jsonb_ord_correctness { // mid `op` (something strictly greater): the "lo < hi" position. let against_greater: bool = sqlx::query_scalar(&format!( - "SELECT '{mid}'::public.eql_v3_jsonb_entry {} '{hi}'::public.eql_v3_jsonb_entry", $op + "SELECT '{mid}'::public.eql_v3_json_entry {} '{hi}'::public.eql_v3_json_entry", $op )).fetch_one(&pool).await?; assert_eq!(against_greater, $lo_rel, "op {} against a strictly-greater leaf", $op); // mid `op` (equal term). let against_equal: bool = sqlx::query_scalar(&format!( - "SELECT '{mid}'::public.eql_v3_jsonb_entry {} '{lo}'::public.eql_v3_jsonb_entry", $op + "SELECT '{mid}'::public.eql_v3_json_entry {} '{lo}'::public.eql_v3_json_entry", $op )).fetch_one(&pool).await?; assert_eq!(against_equal, $eq_rel, "op {} against an equal-term leaf", $op); // hi `op` (something strictly smaller). let against_smaller: bool = sqlx::query_scalar(&format!( - "SELECT '{hi}'::public.eql_v3_jsonb_entry {} '{lo}'::public.eql_v3_jsonb_entry", $op + "SELECT '{hi}'::public.eql_v3_json_entry {} '{lo}'::public.eql_v3_json_entry", $op )).fetch_one(&pool).await?; assert_eq!(against_smaller, $hi_rel, "op {} against a strictly-smaller leaf", $op); @@ -242,7 +242,7 @@ async fn v3_jsonb_op_ladder_is_total_order(pool: PgPool) -> anyhow::Result<()> { let lo = op_entry(w[0]); let hi = op_entry(w[1]); let ok: bool = sqlx::query_scalar(&format!( - "SELECT '{lo}'::public.eql_v3_jsonb_entry < '{hi}'::public.eql_v3_jsonb_entry" + "SELECT '{lo}'::public.eql_v3_json_entry < '{hi}'::public.eql_v3_json_entry" )) .fetch_one(&pool) .await?; @@ -256,7 +256,7 @@ async fn v3_jsonb_op_ladder_is_total_order(pool: PgPool) -> anyhow::Result<()> { let first = op_entry(OP_LADDER[0]); let last = op_entry(OP_LADDER[OP_LADDER.len() - 1]); let end: bool = sqlx::query_scalar(&format!( - "SELECT '{first}'::public.eql_v3_jsonb_entry < '{last}'::public.eql_v3_jsonb_entry" + "SELECT '{first}'::public.eql_v3_json_entry < '{last}'::public.eql_v3_json_entry" )) .fetch_one(&pool) .await?; @@ -279,7 +279,7 @@ async fn v3_jsonb_entry_entry_shape_resolves(pool: PgPool) -> anyhow::Result<()> // Each of the six entry operators resolves on (entry, entry) and returns bool. for op in ["=", "<>", "<", "<=", ">", ">="] { let _v: bool = sqlx::query_scalar(&format!( - "SELECT '{a}'::public.eql_v3_jsonb_entry {op} '{b}'::public.eql_v3_jsonb_entry" + "SELECT '{a}'::public.eql_v3_json_entry {op} '{b}'::public.eql_v3_json_entry" )) .fetch_one(&pool) .await?; @@ -308,7 +308,7 @@ async fn v3_jsonb_containment_hm_only(pool: PgPool) -> anyhow::Result<()> { let root_hm = root_hm_term(&pool).await?; let n = needle(&[(SEL_ROOT_HM, "hm", &root_hm)]); let hits: i64 = sqlx::query_scalar(&format!( - "SELECT count(*) FROM fixtures.v3_ste_vec WHERE payload @> '{n}'::eql_v3.query_jsonb" + "SELECT count(*) FROM fixtures.v3_ste_vec WHERE payload @> '{n}'::eql_v3.query_json" )) .fetch_one(&pool) .await?; @@ -317,9 +317,9 @@ async fn v3_jsonb_containment_hm_only(pool: PgPool) -> anyhow::Result<()> { "every fixture row carries the constant root hm" ); - // Commutator: query_jsonb <@ json must agree row-for-row. + // Commutator: query_json <@ json must agree row-for-row. let hits_rev: i64 = sqlx::query_scalar(&format!( - "SELECT count(*) FROM fixtures.v3_ste_vec WHERE '{n}'::eql_v3.query_jsonb <@ payload" + "SELECT count(*) FROM fixtures.v3_ste_vec WHERE '{n}'::eql_v3.query_json <@ payload" )) .fetch_one(&pool) .await?; @@ -339,7 +339,7 @@ async fn v3_jsonb_containment_op_only(pool: PgPool) -> anyhow::Result<()> { // Row 1 must be among the matches (op terms can repeat across rows). let row1: i64 = sqlx::query_scalar(&format!( - "SELECT count(*) FROM fixtures.v3_ste_vec WHERE id = 1 AND payload @> '{n}'::eql_v3.query_jsonb" + "SELECT count(*) FROM fixtures.v3_ste_vec WHERE id = 1 AND payload @> '{n}'::eql_v3.query_json" )) .fetch_one(&pool) .await?; @@ -347,12 +347,12 @@ async fn v3_jsonb_containment_op_only(pool: PgPool) -> anyhow::Result<()> { // Commutator agreement over the whole table. let fwd: i64 = sqlx::query_scalar(&format!( - "SELECT count(*) FROM fixtures.v3_ste_vec WHERE payload @> '{n}'::eql_v3.query_jsonb" + "SELECT count(*) FROM fixtures.v3_ste_vec WHERE payload @> '{n}'::eql_v3.query_json" )) .fetch_one(&pool) .await?; let rev: i64 = sqlx::query_scalar(&format!( - "SELECT count(*) FROM fixtures.v3_ste_vec WHERE '{n}'::eql_v3.query_jsonb <@ payload" + "SELECT count(*) FROM fixtures.v3_ste_vec WHERE '{n}'::eql_v3.query_json <@ payload" )) .fetch_one(&pool) .await?; @@ -405,7 +405,7 @@ async fn v3_jsonb_containment_mixed(pool: PgPool) -> anyhow::Result<()> { let n = needle(&[(SEL_ROOT_HM, "hm", &root_hm), (SEL_HELLO_OP, "op", &op)]); let row1: i64 = sqlx::query_scalar(&format!( - "SELECT count(*) FROM fixtures.v3_ste_vec WHERE id = 1 AND payload @> '{n}'::eql_v3.query_jsonb" + "SELECT count(*) FROM fixtures.v3_ste_vec WHERE id = 1 AND payload @> '{n}'::eql_v3.query_json" )) .fetch_one(&pool) .await?; @@ -428,7 +428,7 @@ async fn v3_jsonb_containment_self_and_subset(pool: PgPool) -> anyhow::Result<() // Self-containment (json @> json). let self_c: bool = sqlx::query_scalar(&format!( - "SELECT '{full}'::public.eql_v3_json @> '{full}'::public.eql_v3_json" + "SELECT '{full}'::public.eql_v3_json_search @> '{full}'::public.eql_v3_json_search" )) .fetch_one(&pool) .await?; @@ -436,12 +436,12 @@ async fn v3_jsonb_containment_self_and_subset(pool: PgPool) -> anyhow::Result<() // Superset @> subset, and commutator subset <@ superset. let sup: bool = sqlx::query_scalar(&format!( - "SELECT '{full}'::public.eql_v3_json @> '{subset}'::public.eql_v3_json" + "SELECT '{full}'::public.eql_v3_json_search @> '{subset}'::public.eql_v3_json_search" )) .fetch_one(&pool) .await?; let sub: bool = sqlx::query_scalar(&format!( - "SELECT '{subset}'::public.eql_v3_json <@ '{full}'::public.eql_v3_json" + "SELECT '{subset}'::public.eql_v3_json_search <@ '{full}'::public.eql_v3_json_search" )) .fetch_one(&pool) .await?; @@ -452,7 +452,7 @@ async fn v3_jsonb_containment_self_and_subset(pool: PgPool) -> anyhow::Result<() // Subset does NOT contain superset. let backwards: bool = sqlx::query_scalar(&format!( - "SELECT '{subset}'::public.eql_v3_json @> '{full}'::public.eql_v3_json" + "SELECT '{subset}'::public.eql_v3_json_search @> '{full}'::public.eql_v3_json_search" )) .fetch_one(&pool) .await?; @@ -461,12 +461,12 @@ async fn v3_jsonb_containment_self_and_subset(pool: PgPool) -> anyhow::Result<() // entry-needle overload (json @> jsonb_entry) + reverse (entry <@ json). let ent = entry(SEL_ROOT_HM, "hm", HM_TERM_FORGED); let by_entry: bool = sqlx::query_scalar(&format!( - "SELECT '{full}'::public.eql_v3_json @> '{ent}'::public.eql_v3_jsonb_entry" + "SELECT '{full}'::public.eql_v3_json_search @> '{ent}'::public.eql_v3_json_entry" )) .fetch_one(&pool) .await?; let by_entry_rev: bool = sqlx::query_scalar(&format!( - "SELECT '{ent}'::public.eql_v3_jsonb_entry <@ '{full}'::public.eql_v3_json" + "SELECT '{ent}'::public.eql_v3_json_entry <@ '{full}'::public.eql_v3_json_search" )) .fetch_one(&pool) .await?; @@ -525,7 +525,7 @@ async fn v3_jsonb_raw_helpers_contains_and_contained_by(pool: PgPool) -> anyhow: // The raw helper must agree with the typed `@>` operator (which binds to // eql_v3.ste_vec_contains, not this function) on the same well-formed inputs. let typed: bool = sqlx::query_scalar(&format!( - "SELECT '{full}'::public.eql_v3_json @> '{subset}'::public.eql_v3_json" + "SELECT '{full}'::public.eql_v3_json_search @> '{subset}'::public.eql_v3_json_search" )) .fetch_one(&pool) .await?; @@ -546,7 +546,7 @@ async fn v3_jsonb_raw_helpers_contains_and_contained_by(pool: PgPool) -> anyhow: async fn v3_jsonb_ord_ope_term_entry_branches(pool: PgPool) -> anyhow::Result<()> { let with_op = op_entry(OP_LADDER[0]); let term: Option> = sqlx::query_scalar(&format!( - "SELECT eql_v3.ord_term('{with_op}'::public.eql_v3_jsonb_entry)::bytea" + "SELECT eql_v3.ord_term('{with_op}'::public.eql_v3_json_entry)::bytea" )) .fetch_one(&pool) .await?; @@ -557,7 +557,7 @@ async fn v3_jsonb_ord_ope_term_entry_branches(pool: PgPool) -> anyhow::Result<() let hm_only = entry(SEL_ROOT_HM, "hm", HM_TERM_FORGED); let no_term: Option> = sqlx::query_scalar(&format!( - "SELECT eql_v3.ord_term('{hm_only}'::public.eql_v3_jsonb_entry)::bytea" + "SELECT eql_v3.ord_term('{hm_only}'::public.eql_v3_json_entry)::bytea" )) .fetch_one(&pool) .await?; @@ -631,7 +631,7 @@ async fn v3_jsonb_containment_rejects_wrong_bytes(pool: PgPool) -> anyhow::Resul let root_hm = root_hm_term(&pool).await?; let good = needle(&[(SEL_ROOT_HM, "hm", &root_hm)]); let good_hits: i64 = sqlx::query_scalar(&format!( - "SELECT count(*) FROM fixtures.v3_ste_vec WHERE payload @> '{good}'::eql_v3.query_jsonb" + "SELECT count(*) FROM fixtures.v3_ste_vec WHERE payload @> '{good}'::eql_v3.query_json" )) .fetch_one(&pool) .await?; @@ -643,7 +643,7 @@ async fn v3_jsonb_containment_rejects_wrong_bytes(pool: PgPool) -> anyhow::Resul // Real selector, WRONG hm bytes — must match nothing. let n = needle(&[(SEL_ROOT_HM, "hm", "deadbeefdeadbeefdeadbeefdeadbeef")]); let hits: i64 = sqlx::query_scalar(&format!( - "SELECT count(*) FROM fixtures.v3_ste_vec WHERE payload @> '{n}'::eql_v3.query_jsonb" + "SELECT count(*) FROM fixtures.v3_ste_vec WHERE payload @> '{n}'::eql_v3.query_json" )) .fetch_one(&pool) .await?; @@ -670,12 +670,12 @@ async fn v3_jsonb_containment_rejects_wrong_term_type(pool: PgPool) -> anyhow::R let op_needle = needle(&[(COLLIDE_SEL, "op", COLLIDE_TERM)]); let hm_needle = needle(&[(COLLIDE_SEL, "hm", COLLIDE_TERM)]); let collide_accept: bool = sqlx::query_scalar(&format!( - "SELECT '{hm_doc}'::public.eql_v3_json @> '{hm_needle}'::eql_v3.query_jsonb" + "SELECT '{hm_doc}'::public.eql_v3_json_search @> '{hm_needle}'::eql_v3.query_json" )) .fetch_one(&pool) .await?; let collide_reject: bool = sqlx::query_scalar(&format!( - "SELECT '{hm_doc}'::public.eql_v3_json @> '{op_needle}'::eql_v3.query_jsonb" + "SELECT '{hm_doc}'::public.eql_v3_json_search @> '{op_needle}'::eql_v3.query_json" )) .fetch_one(&pool) .await?; @@ -691,7 +691,7 @@ async fn v3_jsonb_containment_rejects_wrong_term_type(pool: PgPool) -> anyhow::R let root_hm = root_hm_term(&pool).await?; let good = needle(&[(SEL_ROOT_HM, "hm", &root_hm)]); let good_hits: i64 = sqlx::query_scalar(&format!( - "SELECT count(*) FROM fixtures.v3_ste_vec WHERE payload @> '{good}'::eql_v3.query_jsonb" + "SELECT count(*) FROM fixtures.v3_ste_vec WHERE payload @> '{good}'::eql_v3.query_json" )) .fetch_one(&pool) .await?; @@ -703,7 +703,7 @@ async fn v3_jsonb_containment_rejects_wrong_term_type(pool: PgPool) -> anyhow::R // An `op`-field needle carrying the real hm term at the hm selector: rejects. let n = needle(&[(SEL_ROOT_HM, "op", &root_hm)]); let hits: i64 = sqlx::query_scalar(&format!( - "SELECT count(*) FROM fixtures.v3_ste_vec WHERE payload @> '{n}'::eql_v3.query_jsonb" + "SELECT count(*) FROM fixtures.v3_ste_vec WHERE payload @> '{n}'::eql_v3.query_json" )) .fetch_one(&pool) .await?; @@ -721,7 +721,7 @@ async fn v3_jsonb_containment_rejects_wrong_term_type(pool: PgPool) -> anyhow::R .await?; let n2 = needle(&[(SEL_HELLO_OP, "hm", &op)]); let hits2: i64 = sqlx::query_scalar(&format!( - "SELECT count(*) FROM fixtures.v3_ste_vec WHERE payload @> '{n2}'::eql_v3.query_jsonb" + "SELECT count(*) FROM fixtures.v3_ste_vec WHERE payload @> '{n2}'::eql_v3.query_json" )) .fetch_one(&pool) .await?; @@ -739,7 +739,7 @@ async fn v3_jsonb_containment_rejects_wrong_selector(pool: PgPool) -> anyhow::Re let root_hm = root_hm_term(&pool).await?; let good = needle(&[(SEL_ROOT_HM, "hm", &root_hm)]); let good_hits: i64 = sqlx::query_scalar(&format!( - "SELECT count(*) FROM fixtures.v3_ste_vec WHERE payload @> '{good}'::eql_v3.query_jsonb" + "SELECT count(*) FROM fixtures.v3_ste_vec WHERE payload @> '{good}'::eql_v3.query_json" )) .fetch_one(&pool) .await?; @@ -751,7 +751,7 @@ async fn v3_jsonb_containment_rejects_wrong_selector(pool: PgPool) -> anyhow::Re // Right term bytes, but a selector that exists in no fixture row. let n = needle(&[("ffffffffffffffffffffffffffffffff", "hm", &root_hm)]); let hits: i64 = sqlx::query_scalar(&format!( - "SELECT count(*) FROM fixtures.v3_ste_vec WHERE payload @> '{n}'::eql_v3.query_jsonb" + "SELECT count(*) FROM fixtures.v3_ste_vec WHERE payload @> '{n}'::eql_v3.query_json" )) .fetch_one(&pool) .await?; @@ -799,23 +799,23 @@ const NN_DOC: &str = r#"{"i":{},"v":3,"sv":[]}"#; v3_jsonb_supported_null!( // entry comparisons (= <> < <= > >=), NULL on each side - (entry_eq_lhs, "SELECT NULL::public.eql_v3_jsonb_entry = '{\"s\":\"r\",\"c\":\"x\",\"hm\":\"00\"}'::public.eql_v3_jsonb_entry"), - (entry_eq_rhs, "SELECT '{\"s\":\"r\",\"c\":\"x\",\"hm\":\"00\"}'::public.eql_v3_jsonb_entry = NULL::public.eql_v3_jsonb_entry"), - (entry_neq_lhs, "SELECT NULL::public.eql_v3_jsonb_entry <> '{\"s\":\"r\",\"c\":\"x\",\"hm\":\"00\"}'::public.eql_v3_jsonb_entry"), - (entry_lt_lhs, "SELECT NULL::public.eql_v3_jsonb_entry < '{\"s\":\"r\",\"c\":\"x\",\"op\":\"00\"}'::public.eql_v3_jsonb_entry"), - (entry_lte_lhs, "SELECT NULL::public.eql_v3_jsonb_entry <= '{\"s\":\"r\",\"c\":\"x\",\"op\":\"00\"}'::public.eql_v3_jsonb_entry"), - (entry_gt_lhs, "SELECT NULL::public.eql_v3_jsonb_entry > '{\"s\":\"r\",\"c\":\"x\",\"op\":\"00\"}'::public.eql_v3_jsonb_entry"), - (entry_gte_lhs, "SELECT NULL::public.eql_v3_jsonb_entry >= '{\"s\":\"r\",\"c\":\"x\",\"op\":\"00\"}'::public.eql_v3_jsonb_entry"), + (entry_eq_lhs, "SELECT NULL::public.eql_v3_json_entry = '{\"s\":\"r\",\"c\":\"x\",\"hm\":\"00\"}'::public.eql_v3_json_entry"), + (entry_eq_rhs, "SELECT '{\"s\":\"r\",\"c\":\"x\",\"hm\":\"00\"}'::public.eql_v3_json_entry = NULL::public.eql_v3_json_entry"), + (entry_neq_lhs, "SELECT NULL::public.eql_v3_json_entry <> '{\"s\":\"r\",\"c\":\"x\",\"hm\":\"00\"}'::public.eql_v3_json_entry"), + (entry_lt_lhs, "SELECT NULL::public.eql_v3_json_entry < '{\"s\":\"r\",\"c\":\"x\",\"op\":\"00\"}'::public.eql_v3_json_entry"), + (entry_lte_lhs, "SELECT NULL::public.eql_v3_json_entry <= '{\"s\":\"r\",\"c\":\"x\",\"op\":\"00\"}'::public.eql_v3_json_entry"), + (entry_gt_lhs, "SELECT NULL::public.eql_v3_json_entry > '{\"s\":\"r\",\"c\":\"x\",\"op\":\"00\"}'::public.eql_v3_json_entry"), + (entry_gte_lhs, "SELECT NULL::public.eql_v3_json_entry >= '{\"s\":\"r\",\"c\":\"x\",\"op\":\"00\"}'::public.eql_v3_json_entry"), // document containment: json @> json - (doc_contains_doc_lhs, "SELECT NULL::public.eql_v3_json @> '{\"i\":{},\"v\":3,\"sv\":[]}'::public.eql_v3_json"), - (doc_contains_doc_rhs, "SELECT '{\"i\":{},\"v\":3,\"sv\":[]}'::public.eql_v3_json @> NULL::public.eql_v3_json"), - // json @> query_jsonb / json @> jsonb_entry - (doc_contains_query_lhs, "SELECT NULL::public.eql_v3_json @> '{\"sv\":[]}'::eql_v3.query_jsonb"), - (doc_contains_query_rhs, "SELECT '{\"i\":{},\"v\":3,\"sv\":[]}'::public.eql_v3_json @> NULL::eql_v3.query_jsonb"), - (doc_contains_entry_rhs, "SELECT '{\"i\":{},\"v\":3,\"sv\":[]}'::public.eql_v3_json @> NULL::public.eql_v3_jsonb_entry"), + (doc_contains_doc_lhs, "SELECT NULL::public.eql_v3_json_search @> '{\"i\":{},\"v\":3,\"sv\":[]}'::public.eql_v3_json_search"), + (doc_contains_doc_rhs, "SELECT '{\"i\":{},\"v\":3,\"sv\":[]}'::public.eql_v3_json_search @> NULL::public.eql_v3_json_search"), + // json @> query_json / json @> jsonb_entry + (doc_contains_query_lhs, "SELECT NULL::public.eql_v3_json_search @> '{\"sv\":[]}'::eql_v3.query_json"), + (doc_contains_query_rhs, "SELECT '{\"i\":{},\"v\":3,\"sv\":[]}'::public.eql_v3_json_search @> NULL::eql_v3.query_json"), + (doc_contains_entry_rhs, "SELECT '{\"i\":{},\"v\":3,\"sv\":[]}'::public.eql_v3_json_search @> NULL::public.eql_v3_json_entry"), // <@ reverses - (query_contained_lhs, "SELECT NULL::eql_v3.query_jsonb <@ '{\"i\":{},\"v\":3,\"sv\":[]}'::public.eql_v3_json"), - (entry_contained_lhs, "SELECT NULL::public.eql_v3_jsonb_entry <@ '{\"i\":{},\"v\":3,\"sv\":[]}'::public.eql_v3_json"), + (query_contained_lhs, "SELECT NULL::eql_v3.query_json <@ '{\"i\":{},\"v\":3,\"sv\":[]}'::public.eql_v3_json_search"), + (entry_contained_lhs, "SELECT NULL::public.eql_v3_json_entry <@ '{\"i\":{},\"v\":3,\"sv\":[]}'::public.eql_v3_json_search"), ); // The `-> text` / `-> int` / `->> text` accessors return non-boolean types, so @@ -824,19 +824,19 @@ v3_jsonb_supported_null!( #[sqlx::test] async fn v3_jsonb_arrow_accessors_supported_null(pool: PgPool) -> anyhow::Result<()> { let arrow_text: Option = - sqlx::query_scalar("SELECT (NULL::public.eql_v3_json -> 'x'::text)::jsonb::text") + sqlx::query_scalar("SELECT (NULL::public.eql_v3_json_search -> 'x'::text)::jsonb::text") .fetch_one(&pool) .await?; assert!(arrow_text.is_none(), "json -> text must propagate NULL"); let arrow_int: Option = - sqlx::query_scalar("SELECT (NULL::public.eql_v3_json -> 0::integer)::jsonb::text") + sqlx::query_scalar("SELECT (NULL::public.eql_v3_json_search -> 0::integer)::jsonb::text") .fetch_one(&pool) .await?; assert!(arrow_int.is_none(), "json -> int must propagate NULL"); let arrow_text_text: Option = - sqlx::query_scalar("SELECT NULL::public.eql_v3_json ->> 'x'::text") + sqlx::query_scalar("SELECT NULL::public.eql_v3_json_search ->> 'x'::text") .fetch_one(&pool) .await?; assert!( @@ -845,7 +845,7 @@ async fn v3_jsonb_arrow_accessors_supported_null(pool: PgPool) -> anyhow::Result ); let arrow_int_text: Option = - sqlx::query_scalar("SELECT NULL::public.eql_v3_json ->> 0::integer") + sqlx::query_scalar("SELECT NULL::public.eql_v3_json_search ->> 0::integer") .fetch_one(&pool) .await?; assert!(arrow_int_text.is_none(), "json ->> int must propagate NULL"); @@ -863,7 +863,7 @@ macro_rules! v3_jsonb_blocker_cases { $( paste::paste! { #[sqlx::test] async fn [](pool: PgPool) -> anyhow::Result<()> { - let lhs = format!("'{}'::public.eql_v3_json", NN_DOC); + let lhs = format!("'{}'::public.eql_v3_json_search", NN_DOC); let msg = "is not supported"; // Domain on the left, real-typed RHS — must raise. @@ -872,16 +872,16 @@ macro_rules! v3_jsonb_blocker_cases { // Non-STRICT proof: NULL domain LHS must STILL raise (a STRICT // blocker would short-circuit to NULL and bypass the exception). - let null_lhs = format!("SELECT NULL::public.eql_v3_json {} {}", $op, $rhs); + let null_lhs = format!("SELECT NULL::public.eql_v3_json_search {} {}", $op, $rhs); eql_tests::assert_raises(&pool, &null_lhs, &[], msg).await?; // Domain on the RIGHT, only where the surface defines that form. let rhs_dom: Option<&str> = $rhs_domain; if let Some(_) = rhs_dom { - let sql = format!("SELECT {} {} '{}'::public.eql_v3_json", $rhs, $op, NN_DOC); + let sql = format!("SELECT {} {} '{}'::public.eql_v3_json_search", $rhs, $op, NN_DOC); eql_tests::assert_raises(&pool, &sql, &[], msg).await?; // Non-STRICT proof for the right-domain form. - let null_rhs = format!("SELECT {} {} NULL::public.eql_v3_json", $rhs, $op); + let null_rhs = format!("SELECT {} {} NULL::public.eql_v3_json_search", $rhs, $op); eql_tests::assert_raises(&pool, &null_rhs, &[], msg).await?; } Ok(()) @@ -965,8 +965,8 @@ v3_jsonb_blocker_cases!( #[sqlx::test] async fn v3_jsonb_root_doc_doc_comparison_blockers(pool: PgPool) -> anyhow::Result<()> { - let lhs = format!("'{}'::public.eql_v3_json", NN_DOC); - let rhs = format!("'{}'::public.eql_v3_json", NN_DOC); + let lhs = format!("'{}'::public.eql_v3_json_search", NN_DOC); + let rhs = format!("'{}'::public.eql_v3_json_search", NN_DOC); for op in ["=", "<>", "<", "<=", ">", ">="] { let sql = format!("SELECT {lhs} {op} {rhs}"); eql_tests::assert_raises(&pool, &sql, &[], "is not supported").await?; @@ -976,7 +976,7 @@ async fn v3_jsonb_root_doc_doc_comparison_blockers(pool: PgPool) -> anyhow::Resu // D7 (negative control) — pins the domain-flattening rule that makes the typed // RHS in `v3_jsonb_blocker_cases!` LOAD-BEARING (file header, lines 13–20). A -// BARE (unknown-typed) operand flattens `public.eql_v3_json` to native `jsonb`, so the +// BARE (unknown-typed) operand flattens `public.eql_v3_json_search` to native `jsonb`, so the // SAME operator that RAISES with a typed RHS in D7 must SUCCEED here — resolving // to native and returning a value, never reaching our blocker. Without this, the // `::text` / `::jsonb` typing in D7 could silently become unnecessary (or, worse, @@ -984,7 +984,7 @@ async fn v3_jsonb_root_doc_doc_comparison_blockers(pool: PgPool) -> anyhow::Resu // would notice. See the "Typed operands" caveat in `docs/reference/json-support.md`. #[sqlx::test] async fn v3_jsonb_bare_operand_flattens_to_native(pool: PgPool) -> anyhow::Result<()> { - let doc = format!("'{}'::public.eql_v3_json", NN_DOC); + let doc = format!("'{}'::public.eql_v3_json_search", NN_DOC); // `?` is blocked with a typed RHS in D7 (`question`). Bare `'sv'` is unknown // -> native `jsonb ? text` -> top-level key present -> TRUE, no raise. @@ -1033,7 +1033,7 @@ async fn v3_jsonb_bare_operand_flattens_to_native(pool: PgPool) -> anyhow::Resul // D7 (negative control, finding #1) — the `->`/`->>` SUPPORTED operators are the // DANGEROUS face of domain-flattening. Unlike the blockers above (typed RHS // RAISES, bare RHS merely succeeds-as-native), `->`/`->>` SILENTLY return a WRONG -// answer for a bare untyped selector: `doc -> 'sel'` flattens `public.eql_v3_json` to +// answer for a bare untyped selector: `doc -> 'sel'` flattens `public.eql_v3_json_search` to // native `jsonb -> text` (a root-key lookup on the envelope), NOT the v3 // selector-lookup operator. This pins BOTH which operator binds (`pg_typeof`) and // the user-visible divergence, so a future resolution change in either direction @@ -1042,11 +1042,11 @@ async fn v3_jsonb_bare_operand_flattens_to_native(pool: PgPool) -> anyhow::Resul // domain to its base `jsonb`, and the native operator wins the exact-match // tiebreak); it is mitigated only by the Proxy always sending typed `$n` // parameters. A direct-SQL caller writing the bare form gets native semantics -// with no error. See the `@warning` in `src/v3/jsonb/operators.sql:20-28` and the +// with no error. See the `@warning` in `src/v3/json/operators.sql:20-28` and the // "Typed operands" caveat in `docs/reference/json-support.md`. #[sqlx::test] async fn v3_jsonb_arrow_bare_operand_flattens_to_native(pool: PgPool) -> anyhow::Result<()> { - let doc = format!("'{}'::public.eql_v3_json", NN_DOC); + let doc = format!("'{}'::public.eql_v3_json_search", NN_DOC); // --- `->` : which operator binds? ------------------------------------- // Bare selector -> NATIVE `jsonb -> text` (result type is `jsonb`). @@ -1056,9 +1056,9 @@ async fn v3_jsonb_arrow_bare_operand_flattens_to_native(pool: PgPool) -> anyhow: assert_eq!( bare_ty, "jsonb", "bare `->` must flatten to native `jsonb -> text`; binding the v3 operator \ - (public.eql_v3_jsonb_entry) here would mean the domain-flattening contract changed" + (public.eql_v3_json_entry) here would mean the domain-flattening contract changed" ); - // Typed selector -> the v3 operator (result type is `public.eql_v3_jsonb_entry`). + // Typed selector -> the v3 operator (result type is `public.eql_v3_json_entry`). let typed_ty: String = sqlx::query_scalar(&format!("SELECT pg_typeof({doc} -> 'sv'::text)::text")) .fetch_one(&pool) @@ -1066,7 +1066,7 @@ async fn v3_jsonb_arrow_bare_operand_flattens_to_native(pool: PgPool) -> anyhow: assert!( matches!( typed_ty.as_str(), - "public.eql_v3_jsonb_entry" | "eql_v3_jsonb_entry" + "public.eql_v3_json_entry" | "eql_v3_json_entry" ), "typed `-> 'sv'::text` must bind the v3 selector-lookup operator" ); @@ -1139,7 +1139,7 @@ macro_rules! v3_jsonb_payload_reject { v3_jsonb_payload_reject!( v3_jsonb_json_payload_check, - "public.eql_v3_json", + "public.eql_v3_json_search", [ "[]", // non-object "{\"v\":3,\"sv\":[]}", // missing i @@ -1157,7 +1157,7 @@ v3_jsonb_payload_reject!( v3_jsonb_payload_reject!( v3_jsonb_ste_vec_entry_payload_check, - "public.eql_v3_jsonb_entry", + "public.eql_v3_json_entry", [ "[]", // non-object "{\"s\":\"x\",\"hm\":\"00\"}", // missing c @@ -1173,7 +1173,7 @@ v3_jsonb_payload_reject!( v3_jsonb_payload_reject!( v3_jsonb_ste_vec_query_payload_check, - "eql_v3.query_jsonb", + "eql_v3.query_json", [ "[]", // non-object "{\"sv\":{}}", // sv not an array @@ -1191,19 +1191,20 @@ v3_jsonb_payload_reject!( /// aren't trivially passing because everything is rejected). #[sqlx::test] async fn v3_jsonb_payload_check_accepts_valid(pool: PgPool) -> anyhow::Result<()> { - let ok_doc: bool = - sqlx::query_scalar("SELECT '{\"i\":{},\"v\":3,\"sv\":[]}'::public.eql_v3_json IS NOT NULL") - .fetch_one(&pool) - .await?; + let ok_doc: bool = sqlx::query_scalar( + "SELECT '{\"i\":{},\"v\":3,\"sv\":[]}'::public.eql_v3_json_search IS NOT NULL", + ) + .fetch_one(&pool) + .await?; assert!(ok_doc); let ok_entry: bool = sqlx::query_scalar( - "SELECT '{\"s\":\"x\",\"c\":\"y\",\"hm\":\"00\"}'::public.eql_v3_jsonb_entry IS NOT NULL", + "SELECT '{\"s\":\"x\",\"c\":\"y\",\"hm\":\"00\"}'::public.eql_v3_json_entry IS NOT NULL", ) .fetch_one(&pool) .await?; assert!(ok_entry); let ok_query: bool = sqlx::query_scalar( - "SELECT '{\"sv\":[{\"s\":\"x\",\"hm\":\"00\"}]}'::eql_v3.query_jsonb IS NOT NULL", + "SELECT '{\"sv\":[{\"s\":\"x\",\"hm\":\"00\"}]}'::eql_v3.query_json IS NOT NULL", ) .fetch_one(&pool) .await?; @@ -1213,7 +1214,7 @@ async fn v3_jsonb_payload_check_accepts_valid(pool: PgPool) -> anyhow::Result<() /// D9 — the cipherstash-client SteVec envelope SHAPE (the extra top-level /// `k:"sv"` the generator emits, plus the per-entry `a` array marker) must pass -/// the `public.eql_v3_json` domain CHECK. The static fixture lacked `k`; the generated +/// the `public.eql_v3_json_search` domain CHECK. The static fixture lacked `k`; the generated /// fixture carries it, so this guards the generated fixture against a CHECK /// rejection independently of live encryption (no creds, no fixture load). #[sqlx::test] @@ -1226,13 +1227,13 @@ async fn v3_jsonb_generator_envelope_shape_accepted(pool: PgPool) -> anyhow::Res ] }"#; let ok: bool = sqlx::query_scalar(&format!( - "SELECT '{envelope}'::public.eql_v3_json IS NOT NULL" + "SELECT '{envelope}'::public.eql_v3_json_search IS NOT NULL" )) .fetch_one(&pool) .await?; assert!( ok, - "cipherstash SteVec envelope (root k:\"sv\" + per-entry a) must pass the public.eql_v3_json CHECK" + "cipherstash SteVec envelope (root k:\"sv\" + per-entry a) must pass the public.eql_v3_json_search CHECK" ); Ok(()) } @@ -1254,14 +1255,14 @@ async fn v3_jsonb_path_query_match_and_miss(pool: PgPool) -> anyhow::Result<()> let d = array_doc(); // Matching selector returns exactly one entry row, whose selector is 'aa'. let hits: i64 = sqlx::query_scalar(&format!( - "SELECT count(*) FROM eql_v3.jsonb_path_query('{d}'::public.eql_v3_json::jsonb, 'aa')" + "SELECT count(*) FROM eql_v3.jsonb_path_query('{d}'::public.eql_v3_json_search::jsonb, 'aa')" )) .fetch_one(&pool) .await?; assert_eq!(hits, 1, "one entry matches selector 'aa'"); let sel: String = sqlx::query_scalar(&format!( - "SELECT eql_v3.selector(e) FROM eql_v3.jsonb_path_query('{d}'::public.eql_v3_json::jsonb, 'aa') AS e" + "SELECT eql_v3.selector(e) FROM eql_v3.jsonb_path_query('{d}'::public.eql_v3_json_search::jsonb, 'aa') AS e" )) .fetch_one(&pool) .await?; @@ -1269,7 +1270,7 @@ async fn v3_jsonb_path_query_match_and_miss(pool: PgPool) -> anyhow::Result<()> // Missing selector returns an empty set. let miss: i64 = sqlx::query_scalar(&format!( - "SELECT count(*) FROM eql_v3.jsonb_path_query('{d}'::public.eql_v3_json::jsonb, 'zz')" + "SELECT count(*) FROM eql_v3.jsonb_path_query('{d}'::public.eql_v3_json_search::jsonb, 'zz')" )) .fetch_one(&pool) .await?; @@ -1281,14 +1282,14 @@ async fn v3_jsonb_path_query_match_and_miss(pool: PgPool) -> anyhow::Result<()> async fn v3_jsonb_path_exists_and_first(pool: PgPool) -> anyhow::Result<()> { let d = array_doc(); let exists: bool = sqlx::query_scalar(&format!( - "SELECT eql_v3.jsonb_path_exists('{d}'::public.eql_v3_json::jsonb, 'bb')" + "SELECT eql_v3.jsonb_path_exists('{d}'::public.eql_v3_json_search::jsonb, 'bb')" )) .fetch_one(&pool) .await?; assert!(exists, "selector 'bb' exists"); let missing: bool = sqlx::query_scalar(&format!( - "SELECT eql_v3.jsonb_path_exists('{d}'::public.eql_v3_json::jsonb, 'zz')" + "SELECT eql_v3.jsonb_path_exists('{d}'::public.eql_v3_json_search::jsonb, 'zz')" )) .fetch_one(&pool) .await?; @@ -1296,7 +1297,7 @@ async fn v3_jsonb_path_exists_and_first(pool: PgPool) -> anyhow::Result<()> { // query_first returns the matching entry (selector 'bb'). let first_sel: String = sqlx::query_scalar(&format!( - "SELECT eql_v3.selector(eql_v3.jsonb_path_query_first('{d}'::public.eql_v3_json::jsonb, 'bb'))" + "SELECT eql_v3.selector(eql_v3.jsonb_path_query_first('{d}'::public.eql_v3_json_search::jsonb, 'bb'))" )) .fetch_one(&pool) .await?; @@ -1304,7 +1305,7 @@ async fn v3_jsonb_path_exists_and_first(pool: PgPool) -> anyhow::Result<()> { // query_first on a miss returns NULL. let first_miss: Option = sqlx::query_scalar(&format!( - "SELECT eql_v3.selector(eql_v3.jsonb_path_query_first('{d}'::public.eql_v3_json::jsonb, 'zz'))" + "SELECT eql_v3.selector(eql_v3.jsonb_path_query_first('{d}'::public.eql_v3_json_search::jsonb, 'zz'))" )) .fetch_one(&pool) .await?; @@ -1316,30 +1317,30 @@ async fn v3_jsonb_path_exists_and_first(pool: PgPool) -> anyhow::Result<()> { async fn v3_jsonb_array_length_and_elements(pool: PgPool) -> anyhow::Result<()> { let d = array_doc(); let len: i32 = sqlx::query_scalar(&format!( - "SELECT eql_v3.jsonb_array_length('{d}'::public.eql_v3_json::jsonb)" + "SELECT eql_v3.jsonb_array_length('{d}'::public.eql_v3_json_search::jsonb)" )) .fetch_one(&pool) .await?; assert_eq!(len, 2, "array doc has two elements"); let n: i64 = sqlx::query_scalar(&format!( - "SELECT count(*) FROM eql_v3.jsonb_array_elements('{d}'::public.eql_v3_json::jsonb)" + "SELECT count(*) FROM eql_v3.jsonb_array_elements('{d}'::public.eql_v3_json_search::jsonb)" )) .fetch_one(&pool) .await?; assert_eq!(n, 2, "jsonb_array_elements yields one row per element"); - // jsonb_array_elements returns SETOF public.eql_v3_jsonb_entry — the rows are + // jsonb_array_elements returns SETOF public.eql_v3_json_entry — the rows are // valid entries (the entry extractor accepts them). let sels: Vec = sqlx::query_scalar(&format!( - "SELECT eql_v3.selector(e) FROM eql_v3.jsonb_array_elements('{d}'::public.eql_v3_json::jsonb) AS e ORDER BY 1" + "SELECT eql_v3.selector(e) FROM eql_v3.jsonb_array_elements('{d}'::public.eql_v3_json_search::jsonb) AS e ORDER BY 1" )) .fetch_all(&pool) .await?; assert_eq!(sels, vec!["aa".to_string(), "bb".to_string()]); let texts: i64 = sqlx::query_scalar(&format!( - "SELECT count(*) FROM eql_v3.jsonb_array_elements_text('{d}'::public.eql_v3_json::jsonb)" + "SELECT count(*) FROM eql_v3.jsonb_array_elements_text('{d}'::public.eql_v3_json_search::jsonb)" )) .fetch_one(&pool) .await?; @@ -1351,11 +1352,13 @@ async fn v3_jsonb_array_length_and_elements(pool: PgPool) -> anyhow::Result<()> async fn v3_jsonb_array_length_non_array_raises(pool: PgPool) -> anyhow::Result<()> { // A document WITHOUT the `a:true` array flag is not an array. let not_array = r#"{"i":{},"v":3,"sv":[{"s":"aa","c":"x","hm":"00"}]}"#; - let sql = format!("SELECT eql_v3.jsonb_array_length('{not_array}'::public.eql_v3_json::jsonb)"); + let sql = format!( + "SELECT eql_v3.jsonb_array_length('{not_array}'::public.eql_v3_json_search::jsonb)" + ); eql_tests::assert_raises(&pool, &sql, &[], "non-array").await?; let sql2 = format!( - "SELECT count(*) FROM eql_v3.jsonb_array_elements('{not_array}'::public.eql_v3_json::jsonb)" + "SELECT count(*) FROM eql_v3.jsonb_array_elements('{not_array}'::public.eql_v3_json_search::jsonb)" ); eql_tests::assert_raises(&pool, &sql2, &[], "non-array").await?; Ok(()) @@ -1382,7 +1385,7 @@ async fn v3_jsonb_index_to_ste_vec_query_gin_engages(pool: PgPool) -> anyhow::Re let root_hm = root_hm_term(&pool).await?; let n = needle(&[(SEL_ROOT_HM, "hm", &root_hm)]); let query = - format!("SELECT id FROM fixtures.v3_ste_vec WHERE payload @> '{n}'::eql_v3.query_jsonb"); + format!("SELECT id FROM fixtures.v3_ste_vec WHERE payload @> '{n}'::eql_v3.query_json"); assert_index_scan_uses( &mut *tx, &query, @@ -1462,22 +1465,26 @@ async fn v3_jsonb_to_ste_vec_query_gin_is_cost_chosen(pool: PgPool) -> anyhow::R ); let mut tx = pool.begin().await?; - sqlx::query("CREATE TEMP TABLE v3_jsonb_scale (payload public.eql_v3_json) ON COMMIT DROP") - .execute(&mut *tx) - .await?; + sqlx::query( + "CREATE TEMP TABLE v3_jsonb_scale (payload public.eql_v3_json_search) ON COMMIT DROP", + ) + .execute(&mut *tx) + .await?; // The bulk: 5000 copies of the filler document. sqlx::query( "INSERT INTO v3_jsonb_scale(payload) \ - SELECT $1::jsonb::public.eql_v3_json FROM generate_series(1, 5000)", + SELECT $1::jsonb::public.eql_v3_json_search FROM generate_series(1, 5000)", ) .bind(&filler_payload) .execute(&mut *tx) .await?; // The single selective pivot document. - sqlx::query("INSERT INTO v3_jsonb_scale(payload) VALUES ($1::jsonb::public.eql_v3_json)") - .bind(&pivot_payload) - .execute(&mut *tx) - .await?; + sqlx::query( + "INSERT INTO v3_jsonb_scale(payload) VALUES ($1::jsonb::public.eql_v3_json_search)", + ) + .bind(&pivot_payload) + .execute(&mut *tx) + .await?; sqlx::query( "CREATE INDEX v3_jsonb_scale_gin_idx ON v3_jsonb_scale \ USING gin ((eql_v3.to_ste_vec_query(payload)::jsonb) jsonb_path_ops)", @@ -1494,7 +1501,7 @@ async fn v3_jsonb_to_ste_vec_query_gin_is_cost_chosen(pool: PgPool) -> anyhow::R // op, exactly the single pivot row contains it. let n = needle(&[(SEL_HELLO_OP, "op", &pivot_op)]); let query = - format!("SELECT count(*) FROM v3_jsonb_scale WHERE payload @> '{n}'::eql_v3.query_jsonb"); + format!("SELECT count(*) FROM v3_jsonb_scale WHERE payload @> '{n}'::eql_v3.query_json"); assert_index_scan_uses( &mut *tx, &query, @@ -1563,23 +1570,24 @@ async fn v3_jsonb_arrow_integer_index_on_array(pool: PgPool) -> anyhow::Result<( // `-> 0` / `-> 1` index the sv array positionally (native jsonb path), not a // selector lookup. Selectors come out in array order. let i0: String = sqlx::query_scalar(&format!( - "SELECT eql_v3.selector('{d}'::public.eql_v3_json -> 0::integer)" + "SELECT eql_v3.selector('{d}'::public.eql_v3_json_search -> 0::integer)" )) .fetch_one(&pool) .await?; assert_eq!(i0, "aa", "-> 0 must index the first sv element"); let i1: String = sqlx::query_scalar(&format!( - "SELECT eql_v3.selector('{d}'::public.eql_v3_json -> 1::integer)" + "SELECT eql_v3.selector('{d}'::public.eql_v3_json_search -> 1::integer)" )) .fetch_one(&pool) .await?; assert_eq!(i1, "bb", "-> 1 must index the second sv element"); - let t1: String = - sqlx::query_scalar(&format!("SELECT '{d}'::public.eql_v3_json ->> 1::integer")) - .fetch_one(&pool) - .await?; + let t1: String = sqlx::query_scalar(&format!( + "SELECT '{d}'::public.eql_v3_json_search ->> 1::integer" + )) + .fetch_one(&pool) + .await?; assert!( t1.contains("\"s\": \"bb\""), "->> 1 must serialize the second sv element, got {t1}" @@ -1588,7 +1596,7 @@ async fn v3_jsonb_arrow_integer_index_on_array(pool: PgPool) -> anyhow::Result<( // Regression: `-> 'sv'::text` is a SELECTOR lookup (our text operator), NOT // native key access — there is no element with selector 'sv', so NULL. let sv_lookup: Option = sqlx::query_scalar(&format!( - "SELECT eql_v3.selector('{d}'::public.eql_v3_json -> 'sv'::text)" + "SELECT eql_v3.selector('{d}'::public.eql_v3_json_search -> 'sv'::text)" )) .fetch_one(&pool) .await?; @@ -1615,8 +1623,8 @@ async fn v3_jsonb_entry_operators_declare_commutator_negator(pool: PgPool) -> an FROM pg_operator o LEFT JOIN pg_operator com ON com.oid = o.oprcom LEFT JOIN pg_operator neg ON neg.oid = o.oprnegate - WHERE o.oprleft = 'public.eql_v3_jsonb_entry'::regtype - AND o.oprright = 'public.eql_v3_jsonb_entry'::regtype + WHERE o.oprleft = 'public.eql_v3_json_entry'::regtype + AND o.oprright = 'public.eql_v3_json_entry'::regtype ORDER BY o.oprname "#, ) @@ -1660,8 +1668,8 @@ async fn v3_jsonb_entry_eq_does_not_declare_hashes_or_merges(pool: PgPool) -> an SELECT oprcanhash, oprcanmerge FROM pg_operator WHERE oprname = '=' - AND oprleft = 'public.eql_v3_jsonb_entry'::regtype - AND oprright = 'public.eql_v3_jsonb_entry'::regtype + AND oprleft = 'public.eql_v3_json_entry'::regtype + AND oprright = 'public.eql_v3_json_entry'::regtype "#, ) .fetch_one(&pool) diff --git a/tests/sqlx/tests/v3_operator_equivalents_tests.rs b/tests/sqlx/tests/v3_operator_equivalents_tests.rs index 7c38207cf..f0eb4eaea 100644 --- a/tests/sqlx/tests/v3_operator_equivalents_tests.rs +++ b/tests/sqlx/tests/v3_operator_equivalents_tests.rs @@ -25,7 +25,7 @@ use sqlx::PgPool; /// Every EQL COLUMN-domain name in the `public` schema, from the catalog: the /// storage and capability domains of every family. The jsonb needle -/// (`query_jsonb`) is a query operand and lives in `eql_v3`, so `full_name`s +/// (`query_json`) is a query operand and lives in `eql_v3`, so `full_name`s /// starting with `query_` are excluded here (see [`eql_query_domain_names`]). /// The structural scan below identifies "an EQL operator" by these names — /// the column domains deliberately live in `public` (dropping EQL-owned @@ -41,7 +41,7 @@ fn eql_public_domain_names() -> Vec { /// Every EQL QUERY-OPERAND domain name, from the catalog: the `query_` /// twin of every term-bearing scalar domain plus the jsonb containment needle -/// (`query_jsonb`). These live in the `eql_v3` schema (CIP-3442) — never +/// (`query_json`). These live in the `eql_v3` schema (CIP-3442) — never /// valid column types, so they don't share the column domains' `public` home. fn eql_query_domain_names() -> Vec { let mut names: Vec = eql_domains::scalar_families() @@ -52,7 +52,7 @@ fn eql_query_domain_names() -> Vec { .map(move |d| d.query_name(f.name)) }) .collect(); - names.push("query_jsonb".to_string()); + names.push("query_json".to_string()); names } diff --git a/tests/sqlx/tests/v3_privilege_tests.rs b/tests/sqlx/tests/v3_privilege_tests.rs index 7aa00e5f5..ace61d42f 100644 --- a/tests/sqlx/tests/v3_privilege_tests.rs +++ b/tests/sqlx/tests/v3_privilege_tests.rs @@ -12,7 +12,7 @@ //! Not every path crosses the boundary, and the tests below pin the difference: //! the hand-written jsonb (SteVec) `ste_vec_contains` read path is `plpgsql` //! (never inlined) and runs under the public grant alone. Casting raw jsonb to -//! `public.eql_v3_json` also stays outside `eql_v3_internal`: the domain CHECK calls +//! `public.eql_v3_json_search` also stays outside `eql_v3_internal`: the domain CHECK calls //! public validators so application table columns can survive EQL schema //! uninstall without dependency edges back into the droppable schemas. //! @@ -55,10 +55,10 @@ const AGG_QUERY: &str = "SELECT eql_v3.min(payload::public.eql_v3_integer_ord) \ const JSONB_READ_QUERY: &str = "SELECT eql_v3.ste_vec_contains(payload, payload) \ FROM fixtures.v3_ste_vec LIMIT 1"; -/// A real jsonb WRITE path: casting raw jsonb to the `public.eql_v3_json` domain fires +/// A real jsonb WRITE path: casting raw jsonb to the `public.eql_v3_json_search` domain fires /// the domain CHECK, which calls public validators and does not cross into /// `eql_v3_internal`. -const JSONB_WRITE_QUERY: &str = "SELECT (payload::jsonb)::public.eql_v3_json \ +const JSONB_WRITE_QUERY: &str = "SELECT (payload::jsonb)::public.eql_v3_json_search \ FROM fixtures.v3_ste_vec LIMIT 1"; /// Derive a unique, valid role name from the per-test database name so parallel @@ -245,9 +245,9 @@ async fn runtime_role_without_internal_grant_is_denied(pool: PgPool) -> Result<( // ============================================================================ /// Positive (jsonb): a runtime role granted USAGE + EXECUTE on BOTH schemas can -/// run both the SteVec containment read and the `public.eql_v3_json` cast (write) path. +/// run both the SteVec containment read and the `public.eql_v3_json_search` cast (write) path. #[sqlx::test(fixtures(path = "../fixtures", scripts("v3_ste_vec")))] -async fn runtime_role_with_both_schema_grants_can_query_jsonb(pool: PgPool) -> Result<()> { +async fn runtime_role_with_both_schema_grants_can_query_json(pool: PgPool) -> Result<()> { let mut conn = pool.acquire().await?; let role = create_isolated_role(&mut conn).await?; @@ -278,7 +278,7 @@ async fn runtime_role_with_both_schema_grants_can_query_jsonb(pool: PgPool) -> R /// Boundary (jsonb): a runtime role granted only the PUBLIC schema (`eql_v3`) /// characterises the SteVec split precisely — both the `plpgsql` containment -/// READ and the `public.eql_v3_json` domain CHECK validator path run without the +/// READ and the `public.eql_v3_json_search` domain CHECK validator path run without the /// internal grant. #[sqlx::test(fixtures(path = "../fixtures", scripts("v3_ste_vec")))] async fn runtime_role_without_internal_grant_jsonb_boundary(pool: PgPool) -> Result<()> { diff --git a/tests/sqlx/tests/v3_public_surface_tests.rs b/tests/sqlx/tests/v3_public_surface_tests.rs index ddd602a83..13c7c6fe5 100644 --- a/tests/sqlx/tests/v3_public_surface_tests.rs +++ b/tests/sqlx/tests/v3_public_surface_tests.rs @@ -107,7 +107,7 @@ fn user_domain_names() -> Vec { } } names.extend( - ["eql_v3_json", "eql_v3_jsonb_entry"] + ["eql_v3_json_search", "eql_v3_json_entry"] .into_iter() .map(String::from), ); @@ -129,7 +129,7 @@ fn query_domain_names() -> Vec { .map(move |d| d.query_name(f.name)) }) .collect(); - names.push("query_jsonb".to_string()); + names.push("query_json".to_string()); names.sort(); names } diff --git a/tests/sqlx/tests/v3_uninstall_tests.rs b/tests/sqlx/tests/v3_uninstall_tests.rs index 0f8c065f0..670d42dca 100644 --- a/tests/sqlx/tests/v3_uninstall_tests.rs +++ b/tests/sqlx/tests/v3_uninstall_tests.rs @@ -76,7 +76,7 @@ async fn table_exists(pool: &PgPool, table: &str) -> Result { } fn normalize_regtype_name(name: String) -> String { - name.replace("public.\"json\"", "public.eql_v3_json") + name.replace("public.\"json\"", "public.eql_v3_json_search") } #[sqlx::test] @@ -142,7 +142,7 @@ async fn shipped_installer_can_run_over_existing_public_domains(pool: PgPool) -> FROM pg_catalog.pg_type t JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace WHERE n.nspname = 'public' - AND t.typname IN ('eql_v3_integer_eq', 'eql_v3_json', 'eql_v3_jsonb_entry') + AND t.typname IN ('eql_v3_integer_eq', 'eql_v3_json_search', 'eql_v3_json_entry') ORDER BY 1 "#, ) @@ -156,8 +156,8 @@ async fn shipped_installer_can_run_over_existing_public_domains(pool: PgPool) -> public_domains, vec![ "public.eql_v3_integer_eq", - "public.eql_v3_json", - "public.eql_v3_jsonb_entry" + "public.eql_v3_json_search", + "public.eql_v3_json_entry" ], "repeat install must keep public user-column domains available" ); @@ -170,7 +170,7 @@ async fn shipped_installer_can_run_over_existing_public_domains(pool: PgPool) -> FROM pg_catalog.pg_type t JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace WHERE n.nspname = 'eql_v3' - AND t.typname IN ('query_integer_eq', 'query_jsonb') + AND t.typname IN ('query_integer_eq', 'query_json') ORDER BY 1 "#, ) @@ -182,7 +182,7 @@ async fn shipped_installer_can_run_over_existing_public_domains(pool: PgPool) -> query_domains.sort(); assert_eq!( query_domains, - vec!["eql_v3.query_integer_eq", "eql_v3.query_jsonb"], + vec!["eql_v3.query_integer_eq", "eql_v3.query_json"], "repeat install must recreate the eql_v3 query-operand domains" ); @@ -208,8 +208,8 @@ async fn uninstaller_preserves_application_tables_with_public_domain_columns( CREATE TABLE public.eql_v3_uninstall_preserve ( id integer PRIMARY KEY, scalar_value public.eql_v3_integer_eq NOT NULL, - doc_value public.eql_v3_json NOT NULL, - entry_value public.eql_v3_jsonb_entry + doc_value public.eql_v3_json_search NOT NULL, + entry_value public.eql_v3_json_entry ) "#, ) @@ -224,8 +224,8 @@ async fn uninstaller_preserves_application_tables_with_public_domain_columns( ( 1, $1::jsonb::public.eql_v3_integer_eq, - $2::jsonb::public.eql_v3_json, - $3::jsonb::public.eql_v3_jsonb_entry + $2::jsonb::public.eql_v3_json_search, + $3::jsonb::public.eql_v3_json_entry ) "#, ) @@ -243,7 +243,7 @@ async fn uninstaller_preserves_application_tables_with_public_domain_columns( r#" CREATE TABLE public.eql_v3_uninstall_query_misuse ( id integer PRIMARY KEY, - misused_query_value eql_v3.query_jsonb + misused_query_value eql_v3.query_json ) "#, ) @@ -293,8 +293,8 @@ async fn uninstaller_preserves_application_tables_with_public_domain_columns( vec![ "pg_catalog.int4", "public.eql_v3_integer_eq", - "public.eql_v3_json", - "public.eql_v3_jsonb_entry", + "public.eql_v3_json_search", + "public.eql_v3_json_entry", ] ); From 6aa8b96f85d27683a7de98012d3d0cd423fa9569 Mon Sep 17 00:00:00 2001 From: Toby Hede Date: Wed, 15 Jul 2026 10:13:19 +1000 Subject: [PATCH 02/19] fix: apply CodeRabbit auto-fixes --- crates/eql-bindings/src/v3/query_payload.rs | 2 +- crates/eql-domains/src/lib.rs | 4 +- docs/reference/catalog-driven-architecture.md | 26 +++++++------ docs/reference/database-indexes.md | 4 +- src/v3/json/types.sql | 2 +- tasks/test/clean_install_v3.sh | 39 ++++++++++++++++--- tests/sqlx/tests/v3_public_surface_tests.rs | 2 +- tests/sqlx/tests/v3_uninstall_tests.rs | 4 +- 8 files changed, 57 insertions(+), 26 deletions(-) diff --git a/crates/eql-bindings/src/v3/query_payload.rs b/crates/eql-bindings/src/v3/query_payload.rs index 685a693e8..cb55baad9 100644 --- a/crates/eql-bindings/src/v3/query_payload.rs +++ b/crates/eql-bindings/src/v3/query_payload.rs @@ -102,7 +102,7 @@ impl QueryPayload { /// Strictly parse `value` as `domain`'s query payload, KEEPING the /// parsed value — the query-side counterpart of /// [`super::DomainPayload::parse`]. `domain` is the unqualified name - /// (`"query_integer_eq"`, `"query_jsonb"`, …). `None` when `domain` + /// (`"query_integer_eq"`, `"query_json"`, …). `None` when `domain` /// is not a query-operand domain; `Some(Err)` when the strict parse /// fails (`deny_unknown_fields` rejects a stray `c`). pub fn parse( diff --git a/crates/eql-domains/src/lib.rs b/crates/eql-domains/src/lib.rs index 11189a40d..1a0245be9 100644 --- a/crates/eql-domains/src/lib.rs +++ b/crates/eql-domains/src/lib.rs @@ -130,7 +130,7 @@ impl Role { /// The structural shape of a domain's payload. Every existing scalar family is /// [`Shape::Scalar`] (flat `{v,i,c,+terms}`). The SteVec shapes belong to the -/// `jsonb` family and carry document/entry/query payloads whose keys are NOT the +/// `json` family and carry document/entry/query payloads whose keys are NOT the /// flat envelope+term set — `Term`, `Role`, `operators_for_terms`, and /// `capability_label` continue to assume flat-scalar semantics and are simply /// never invoked on a SteVec domain (consumers filter/branch on `Shape`). @@ -150,7 +150,7 @@ pub enum Shape { /// Flat `{v, i, c, +terms}` — every existing scalar family (default). Scalar, /// A `json` family SteVec payload: `public.eql_v3_json_search` - /// (`{v, i, sv: [entry]}`), `public.eql_v3_json_entry` + /// (`{v, k, i, sv: [entry]}`), `public.eql_v3_json_entry` /// (`{s, c, a?, #[flatten] SteVecTerm}`), or `eql_v3.query_json` /// (`{sv: [query-entry]}`). The three differ in payload body but share the /// non-flat-scalar shape, so a single variant covers them; `Domain.name` diff --git a/docs/reference/catalog-driven-architecture.md b/docs/reference/catalog-driven-architecture.md index f1b31d9b4..12615ae75 100644 --- a/docs/reference/catalog-driven-architecture.md +++ b/docs/reference/catalog-driven-architecture.md @@ -191,18 +191,22 @@ flowchart LR | `text` | Text | text-search (equality always routes through `Hm` — ORE is not equality-lossless for text) | | `boolean` | Bool | storage-only (2-value cardinality leak → no searchable index) | -**`jsonb` sits outside this classification.** It carries three domains — `public.eql_v3_json_search` -(document), `public.eql_v3_json_entry` (one `sv` leaf), `eql_v3.query_json` (containment -needle) — each tagged `Shape::SteVec` rather than `Shape::Scalar`, with an empty flat +**`jsonb` sits outside this classification.** It carries four domains. Three are +`Shape::SteVec` — `public.eql_v3_json_search` (document), `public.eql_v3_json_entry` +(one `sv` leaf), `eql_v3.query_json` (containment needle) — each with an empty flat `terms` list: capability lives *structurally* inside the payload (per-`sv`-leaf `hm` -XOR `op`), not as a family-level `Term` set. `Domain.name` (`"json"`/`"entry"`/`"query"`) -disambiguates which of the three a given domain is — see `Domain::rust_struct_name`. -`scalar_families()` filters `CATALOG` down to the `Shape::Scalar` rows, so `jsonb` never -reaches `every_type_uses_a_known_domain_shape`, the ordered-scalar materializer (§3), or -the scalar SQLx matrix. Its SQL surface is hand-written under `src/v3/json/` -(`eql-codegen` renders SQL only for `scalar_families()`) and its Rust structs are -hand-written in `crates/eql-bindings/src/v3/jsonb.rs` — only inventory membership and -`CATALOG` order are catalog-driven. This is also why the class diagram in §2.1 lists +XOR `op`), not as a family-level `Term` set. The fourth is a generated `Shape::Scalar` +storage-only domain, `public.eql_v3_json` (bare `name: ""`, ciphertext-only `{v,i,c}`, +no index terms). `Domain.name` (`"search"`/`"entry"`/`"query"`, and `""` for the storage +domain) disambiguates which one a given domain is — see `Domain::rust_struct_name`. +`scalar_families()` filters `CATALOG` down to families whose domains are *all* +`Shape::Scalar`, so `jsonb` never reaches `every_type_uses_a_known_domain_shape`, the +ordered-scalar materializer (§3), or the scalar SQLx matrix. Its three SteVec domains are +hand-written under `src/v3/json/` and their Rust structs in +`crates/eql-bindings/src/v3/json.rs`; the generated storage domain's SQL is rendered into +`src/v3/scalars/json/` and its struct into `crates/eql-bindings/src/v3/json_storage.rs` +(via `families_with_scalar_domains()`) — for the SteVec domains, only inventory membership +and `CATALOG` order are catalog-driven. This is also why the class diagram in §2.1 lists `Jsonb` as a `ScalarKind` variant even though `jsonb` is not a `Shape::Scalar` family: `ScalarKind` and `Shape` are independent axes, and `JSONB_FIXTURES` (`crates/eql-domains/src/fixtures/record.rs`) needs a `ScalarKind` purely for the diff --git a/docs/reference/database-indexes.md b/docs/reference/database-indexes.md index 7dbed0cec..58ccf80f5 100644 --- a/docs/reference/database-indexes.md +++ b/docs/reference/database-indexes.md @@ -196,7 +196,7 @@ For ordered field-level access, index `eql_v3.ord_term(doc -> ''::text ## GIN Indexes for JSONB Containment -For document-level containment (`@>` / `<@`) on `public.eql_v3_json_search` columns, use a GIN index over the ste_vec query shape. The typed `@>` overload inlines to a native `jsonb @>` over `eql_v3.to_ste_vec_query(col)::jsonb`, so a GIN index on the same expression engages: +For document-level containment (`@>`) on `public.eql_v3_json_search` columns, use a GIN index over the ste_vec query shape. The typed `@>` overload inlines to a native `jsonb @>` over `eql_v3.to_ste_vec_query(col)::jsonb`, so a GIN index on the same expression engages (`jsonb_path_ops` indexes `@>` only, not `<@`): ```sql CREATE INDEX orders_data_gin @@ -214,7 +214,7 @@ The needle must be typed — `$1::eql_v3.query_json`, another `public.eql_v3_jso | Feature | hash / btree on extractor | GIN on `to_ste_vec_query` | | -------------- | ------------------------------ | ------------------------- | | **Use case** | equality, range, ordering | JSONB document containment | -| **Operators** | `=`, `<>`, `<`, `>`, `<=`, `>=` | `@>`, `<@` | +| **Operators** | `=`, `<>`, `<`, `>`, `<=`, `>=` | `@>` | | **Expression** | `eql_v3.eq_term` / `ord_term` | `eql_v3.to_ste_vec_query(col)::jsonb` | --- diff --git a/src/v3/json/types.sql b/src/v3/json/types.sql index ebc442674..e48604d5b 100644 --- a/src/v3/json/types.sql +++ b/src/v3/json/types.sql @@ -124,7 +124,7 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_json_search IS 'EQL encrypted JSONB document (containment, equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_json_search IS 'EQL encrypted JSONB searchable document (containment)'; END $$; diff --git a/tasks/test/clean_install_v3.sh b/tasks/test/clean_install_v3.sh index 3c5fa80e3..84a46854c 100755 --- a/tasks/test/clean_install_v3.sh +++ b/tasks/test/clean_install_v3.sh @@ -71,19 +71,19 @@ BEGIN END $$; SQL -echo "==> smoke: v3 encrypted JSONB surface" +echo "==> smoke: v3 searchable encrypted-JSON (SteVec) surface" "${RUN[@]}" <<'SQL' -CREATE TABLE v3_json_smoke (id int PRIMARY KEY, e public.eql_v3_json); +CREATE TABLE v3_json_smoke (id int PRIMARY KEY, e public.eql_v3_json_search); INSERT INTO v3_json_smoke VALUES - (1, '{"i":{"c":"v3_json_smoke","t":"encrypted"},"v":3,"sv":[{"s":"sel","c":"ciphertext","hm":"00"}]}'::public.eql_v3_json); + (1, '{"i":{"c":"v3_json_smoke","t":"encrypted"},"v":3,"sv":[{"s":"sel","c":"ciphertext","hm":"00"}]}'::public.eql_v3_json_search); -- Supported typed accessors and containment. SELECT (e -> 'sel'::text)::jsonb ->> 'hm' FROM v3_json_smoke WHERE id = 1; SELECT e ->> 'sel'::text FROM v3_json_smoke WHERE id = 1; SELECT count(*) FROM v3_json_smoke -WHERE e @> '{"sv":[{"s":"sel","hm":"00"}]}'::eql_v3.query_jsonb; +WHERE e @> '{"sv":[{"s":"sel","hm":"00"}]}'::eql_v3.query_json; SELECT count(*) FROM v3_json_smoke -WHERE '{"sv":[{"s":"sel","hm":"00"}]}'::eql_v3.query_jsonb <@ e; +WHERE '{"sv":[{"s":"sel","hm":"00"}]}'::eql_v3.query_json <@ e; -- Documented GIN expression installs cleanly in a v3-only database. CREATE INDEX v3_json_smoke_gin @@ -97,7 +97,7 @@ BEGIN PERFORM e ? 'sel'::text FROM v3_json_smoke WHERE id = 1; EXCEPTION WHEN OTHERS THEN raised := true; - IF SQLERRM <> 'operator ? is not supported for public.eql_v3_json' THEN + IF SQLERRM <> 'operator ? is not supported for public.eql_v3_json_search' THEN RAISE EXCEPTION 'json blocker raised an unexpected message: %', SQLERRM; END IF; END; @@ -110,4 +110,31 @@ END $$; DROP TABLE v3_json_smoke; SQL +echo "==> smoke: v3 storage-only encrypted-JSON surface" +"${RUN[@]}" <<'SQL' +-- The bare public.eql_v3_json is ciphertext-only: it accepts a {v,i,c} envelope +-- and rejects a SteVec document (no root c). +CREATE TABLE v3_json_storage_smoke (id int PRIMARY KEY, e public.eql_v3_json); +INSERT INTO v3_json_storage_smoke VALUES + (1, '{"v":"3","i":{"t":"v3_json_storage_smoke","c":"e"},"c":"ciphertext"}'::public.eql_v3_json); +SELECT count(*) FROM v3_json_storage_smoke WHERE id = 1; + +DO $$ +DECLARE + raised boolean := false; +BEGIN + -- A SteVec document (sv, no root c) must be rejected by the storage CHECK. + BEGIN + PERFORM '{"v":"3","i":{},"sv":[{"s":"sel","hm":"00"}]}'::public.eql_v3_json; + EXCEPTION WHEN check_violation THEN + raised := true; + END; + IF NOT raised THEN + RAISE EXCEPTION 'v3 storage json CHECK accepted a SteVec document'; + END IF; +END $$; + +DROP TABLE v3_json_storage_smoke; +SQL + echo "clean v3 install OK (D11 + D4 proven)" diff --git a/tests/sqlx/tests/v3_public_surface_tests.rs b/tests/sqlx/tests/v3_public_surface_tests.rs index 13c7c6fe5..840ca6259 100644 --- a/tests/sqlx/tests/v3_public_surface_tests.rs +++ b/tests/sqlx/tests/v3_public_surface_tests.rs @@ -107,7 +107,7 @@ fn user_domain_names() -> Vec { } } names.extend( - ["eql_v3_json_search", "eql_v3_json_entry"] + ["eql_v3_json", "eql_v3_json_search", "eql_v3_json_entry"] .into_iter() .map(String::from), ); diff --git a/tests/sqlx/tests/v3_uninstall_tests.rs b/tests/sqlx/tests/v3_uninstall_tests.rs index 670d42dca..576cf8036 100644 --- a/tests/sqlx/tests/v3_uninstall_tests.rs +++ b/tests/sqlx/tests/v3_uninstall_tests.rs @@ -156,8 +156,8 @@ async fn shipped_installer_can_run_over_existing_public_domains(pool: PgPool) -> public_domains, vec![ "public.eql_v3_integer_eq", - "public.eql_v3_json_search", - "public.eql_v3_json_entry" + "public.eql_v3_json_entry", + "public.eql_v3_json_search" ], "repeat install must keep public user-column domains available" ); From 5890243356fd709b6bf4b879415d53cc72336b11 Mon Sep 17 00:00:00 2001 From: Toby Hede Date: Wed, 15 Jul 2026 10:43:27 +1000 Subject: [PATCH 03/19] fix: correct stale TOC anchor for json-support querying section --- docs/reference/json-support.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/reference/json-support.md b/docs/reference/json-support.md index 1789b95b6..c23e93d71 100644 --- a/docs/reference/json-support.md +++ b/docs/reference/json-support.md @@ -6,7 +6,7 @@ EQL encrypts, decrypts, and searches JSON / JSONB documents using structured enc - [Storing encrypted JSON](#storing-encrypted-json) - [Typed operands (important)](#typed-operands-important) -- [Querying `public.eql_v3_json_search`](#querying-publicjson) +- [Querying `public.eql_v3_json_search`](#querying-publiceql_v3_json_search) - [Containment queries (`@>`, `<@`)](#containment-queries) - [Field extraction (`jsonb_path_query`)](#field-extraction-jsonb_path_query) - [JSON path operators (`->`, `->>`)](#json-path-operators) From 89a1da5ca3ed5b08a4560ad65b9d8a58c48a65dd Mon Sep 17 00:00:00 2001 From: Toby Hede Date: Wed, 15 Jul 2026 11:19:37 +1000 Subject: [PATCH 04/19] test(json): extract real-ciphertext storage fixture + suite from PR #397 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The storage-domain tests used inline {v,i,c} payloads, which technically violate the project rule that tests must use real ciphertexts, never synthetic blobs. Port PR #397's real-ciphertext approach (adapted to this branch's generated architecture and `json` module naming): - New `v3_json_storage` fixture: encrypts JSON through cipherstash-client with `.storage_only()` (no index) into a real {v,i,c} envelope, column-typed `public.eql_v3_json` so the domain CHECK runs at load. - New `v3_json_storage_tests` suite: a real client payload parses into the generated `Json` binding; `@>` on a real fixture row raises the firewall; the storage/search CHECKs are mutually exclusive on real data. - Fix `v3_convert::targets_for`: an unindexed jsonb fixture now converts to the storage-only `eql_v3_json` target (was unconditionally `eql_v3_json_search`), with a unit test pinning the bare {v,i,c} envelope. - Wire-up: allowlist `public.eql_v3_json`, register the fixture module + generation, gitignore the generated .sql. The inline jsonb_check tests are kept — they cover what fixtures can't (malformed-envelope rejection, the full blocked-operator matrix, and the path-operator fall-through characterization). --- .gitignore | 1 + tests/sqlx/src/fixtures/mod.rs | 8 +- tests/sqlx/src/fixtures/v3_convert.rs | 44 ++++++++-- tests/sqlx/src/fixtures/v3_json_storage.rs | 76 +++++++++++++++++ tests/sqlx/src/fixtures/validation.rs | 11 ++- tests/sqlx/tests/generate_all_fixtures.rs | 8 ++ tests/sqlx/tests/v3_json_storage_tests.rs | 94 ++++++++++++++++++++++ 7 files changed, 232 insertions(+), 10 deletions(-) create mode 100644 tests/sqlx/src/fixtures/v3_json_storage.rs create mode 100644 tests/sqlx/tests/v3_json_storage_tests.rs diff --git a/.gitignore b/.gitignore index 6f08e3ef2..af3f11193 100644 --- a/.gitignore +++ b/.gitignore @@ -227,6 +227,7 @@ tests/sqlx/migrations/001_install_eql.sql # never commit — stale fixtures hide bugs) tests/sqlx/fixtures/eql_v3* tests/sqlx/fixtures/v3_ste_vec.sql +tests/sqlx/fixtures/v3_json_storage.sql tests/sqlx/fixtures/v3_doc_integer.sql tests/sqlx/fixtures/v3_numeric_collision.sql tests/sqlx/fixtures/v3_text_empty.sql diff --git a/tests/sqlx/src/fixtures/mod.rs b/tests/sqlx/src/fixtures/mod.rs index 504348f32..8457c8296 100644 --- a/tests/sqlx/src/fixtures/mod.rs +++ b/tests/sqlx/src/fixtures/mod.rs @@ -31,12 +31,18 @@ pub mod driver; // written fixture satisfies the `v = '3'` domain CHECKs (CIP-3347). pub mod v3_convert; -// The v3 jsonb (SteVec document) fixture — a hand-written `FixtureSpec` +// The v3 json (SteVec document) fixture — a hand-written `FixtureSpec` // over `serde_json::Value`, generated through the same pipeline as the // scalar `eql_v3_` fixtures. Not a CATALOG scalar, so it is registered // here directly rather than via `scalar_types!`. pub mod v3_ste_vec; +// The storage-only / encryption-only json fixture (CIP-3512) — a hand-written +// `FixtureSpec` with NO index, so each document encrypts to a +// plain `{v, i, c}` envelope for the storage-only `public.eql_v3_json` domain. +// Same pipeline as `v3_ste_vec`, minus the SteVec index. +pub mod v3_json_storage; + // The scalar-shaped SteVec document fixture — a SteVec document carrying one // integer scalar at `$.field` per `eql_domains::INTEGER_VALUES`. A SPLIT fixture // (jsonb-document encryption input, integer plaintext oracle), so it uses the diff --git a/tests/sqlx/src/fixtures/v3_convert.rs b/tests/sqlx/src/fixtures/v3_convert.rs index f13c0eeb3..b189d1659 100644 --- a/tests/sqlx/src/fixtures/v3_convert.rs +++ b/tests/sqlx/src/fixtures/v3_convert.rs @@ -36,9 +36,12 @@ //! identical by construction, and the merge fails closed if they ever //! disagree. Every merged key still came out of a validated `from_v2` call. //! -//! The SteVec document fixtures (`v3_ste_vec`, `v3_doc_integer`) convert with -//! the single [`TargetDomain::Json`] target — the v3 document keeps -//! `k: "sv"` (the #336 wire shape) and its per-entry `hm` XOR `op` terms. +//! The SteVec-indexed document fixtures (`v3_ste_vec`, `v3_doc_integer`) convert +//! with the single [`TargetDomain::Json`] target (`eql_v3_json_search`) — the v3 +//! document keeps `k: "sv"` (the #336 wire shape) and its per-entry `hm` XOR `op` +//! terms. A storage-only / encryption-only json fixture (`v3_json_storage`, no +//! index) instead converts to the bare `eql_v3_json` scalar storage target — a +//! plain `{v,i,c}` envelope, no `k`/`sv` (CIP-3512); see `targets_for`. //! Their payloads first pass through [`ste_vec_oc_to_op`], a TEMPORARY shim: //! the pinned 0.38.1 client serializes Compat-mode (CLLW-OPE) sv terms under //! the v2.3 `oc` key, because the v2.3 schema predates a distinct sv-level @@ -131,8 +134,17 @@ fn term_key_for(index: IndexKind) -> Option<&'static str> { /// the single `json` document target for [`ScalarKind::Jsonb`]. fn targets_for(kind: ScalarKind, indexes: &[IndexKind]) -> Result> { if kind == ScalarKind::Jsonb { - let target = TargetDomain::parse("eql_v3_json_search") - .map_err(|e| anyhow!("resolving the SteVec document target: {e}"))?; + // A SteVec-indexed jsonb fixture converts to the searchable document + // domain (`eql_v3_json_search`, `k: "sv"`); an unindexed / storage-only + // jsonb fixture converts to the storage-only `eql_v3_json` domain — a + // plain `{v,i,c}` envelope (CIP-3512). + let name = if indexes.contains(&IndexKind::SteVec) { + "eql_v3_json_search" + } else { + "eql_v3_json" + }; + let target = TargetDomain::parse(name) + .map_err(|e| anyhow!("resolving the jsonb conversion target {name:?}: {e}"))?; return Ok(vec![target]); } @@ -396,6 +408,28 @@ mod tests { assert_eq!(sv[1].get("a"), Some(&json!(false))); } + #[test] + fn storage_only_jsonb_converts_to_the_bare_envelope() { + // A storage-only / encryption-only json fixture (CIP-3512): kind Jsonb + // but NO SteVec index, so the client encrypts the whole document as one + // `k: "ct"` ciphertext and the v3 payload is exactly `{v, i, c}` for the + // storage-only `eql_v3_json` domain — NOT a SteVec document. + let payload = json!({ + "v": 2, + "k": "ct", + "i": { "t": "_fixture_v3_json_storage", "c": "payload" }, + "c": "mBbKmsMMkbKAJcY2ZE!ceh0e1t", + }); + let out = to_v3_payloads(vec![payload], ScalarKind::Jsonb, &[]).unwrap(); + let obj = out[0].as_object().unwrap(); + assert_eq!(obj.get("v"), Some(&json!(3))); + assert!(!obj.contains_key("k"), "storage-only json carries no `k`"); + assert!(!obj.contains_key("sv"), "storage-only json carries no `sv`"); + let mut keys: Vec<&str> = obj.keys().map(String::as_str).collect(); + keys.sort_unstable(); + assert_eq!(keys, ["c", "i", "v"]); + } + #[test] fn missing_term_fails_closed() { // A `unique`+`ore` fixture whose payload lost `ob` must crash the diff --git a/tests/sqlx/src/fixtures/v3_json_storage.rs b/tests/sqlx/src/fixtures/v3_json_storage.rs new file mode 100644 index 000000000..91122c1eb --- /dev/null +++ b/tests/sqlx/src/fixtures/v3_json_storage.rs @@ -0,0 +1,76 @@ +//! The `v3_json_storage` fixture — the storage-only / encryption-only json +//! analogue of `v3_ste_vec`, generated through the SAME `FixtureSpec` +//! machinery but with NO index (`.storage_only()`). cipherstash-client +//! therefore encrypts each JSON document into a plain `{v, i, c}` envelope (the +//! JSON analogue of a scalar storage payload) rather than a SteVec document. +//! +//! The generated `payload` column is the storage-only `public.eql_v3_json` +//! DOMAIN (CIP-3512), so its CHECK runs when the fixture loads. This gives the +//! storage-only json domain — and its native-jsonb operator firewall (generated +//! under `src/v3/scalars/json/`) — a real-ciphertext home, exactly as the `bool` +//! scalar storage fixture does for the scalar storage domains. + +use anyhow::Result; +use serde_json::{json, Value}; + +use super::spec::FixtureSpec; + +/// The canonical fixture name → table `fixtures.v3_json_storage`, script +/// `v3_json_storage.sql`, SQLx ref `scripts("v3_json_storage")`. +const NAME: &str = "v3_json_storage"; + +/// The canonical `payload` column type — the storage-only `public.eql_v3_json` +/// DOMAIN, so the `{v, i, c}` envelope CHECK runs when the fixture loads. +const PAYLOAD_TYPE: &str = "public.eql_v3_json"; + +/// Number of fixture rows. A small non-trivial set is enough — the storage-only +/// domain is not searchable, so there is no oracle to discriminate; the rows +/// exist to prove real ciphertexts load, decrypt, and reject native jsonb ops. +const ROW_COUNT: i64 = 3; + +/// The plaintext documents — the source of truth for the fixture. Distinct +/// per row so a decrypt round-trip has something to compare against. +fn documents() -> Vec { + (1..=ROW_COUNT) + .map(|i| { + json!({ + "hello": format!("world-{i}"), + "number": i, + "nested": { "deep": "constant" }, + }) + }) + .collect() +} + +/// Generate `tests/sqlx/fixtures/v3_json_storage.sql` by encrypting the +/// plaintext documents through the shared `FixtureSpec` pipeline with NO index +/// (`.storage_only()`), so each becomes a plain `{v, i, c}` storage-only json +/// payload. +pub async fn generate() -> Result<()> { + let docs = documents(); + FixtureSpec::new(NAME) + .storage_only() + .with_column_type(PAYLOAD_TYPE) + .with_values(&docs) + .run() + .await +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn spec_builds_a_storage_only_json_fixture() { + let docs = documents(); + let spec = FixtureSpec::new(NAME) + .storage_only() + .with_column_type(PAYLOAD_TYPE) + .with_values(&docs); + assert_eq!(spec.fixture_table(), "fixtures.v3_json_storage"); + assert_eq!(spec.column_type().as_str(), "public.eql_v3_json"); + // Storage-only / encryption-only: the fixture declares zero indexes. + assert!(spec.indexes().is_empty()); + assert!(spec.check_complete().is_ok()); + } +} diff --git a/tests/sqlx/src/fixtures/validation.rs b/tests/sqlx/src/fixtures/validation.rs index 87115de10..9362538cc 100644 --- a/tests/sqlx/src/fixtures/validation.rs +++ b/tests/sqlx/src/fixtures/validation.rs @@ -25,11 +25,14 @@ fn is_valid_identifier(s: &str) -> bool { } /// Allowlist of generated `payload` column types. `jsonb` for the scalar -/// fixtures; `public.eql_v3_json_search` for the v3 jsonb (SteVec document) fixture, whose +/// fixtures; `public.eql_v3_json_search` for the v3 json (SteVec document) fixture, whose /// generated `payload` column is the `public.eql_v3_json_search` DOMAIN so the domain CHECK -/// runs on load. Schema-qualified tokens are allowed — each is an exact, -/// vetted entry here, never a free-form `&str`. -pub const ALLOWED_COLUMN_TYPES: &[&str] = &["jsonb", "public.eql_v3_json_search"]; +/// runs on load; and `public.eql_v3_json` for the storage-only / encryption-only json +/// fixture (CIP-3512), whose `payload` column is that DOMAIN so its `{v,i,c}` CHECK runs on +/// load. Schema-qualified tokens are allowed — each is an exact, vetted entry here, never a +/// free-form `&str`. +pub const ALLOWED_COLUMN_TYPES: &[&str] = + &["jsonb", "public.eql_v3_json", "public.eql_v3_json_search"]; fn is_valid_column_type(s: &str) -> bool { ALLOWED_COLUMN_TYPES.contains(&s) diff --git a/tests/sqlx/tests/generate_all_fixtures.rs b/tests/sqlx/tests/generate_all_fixtures.rs index 268d14be5..23cd2a5db 100644 --- a/tests/sqlx/tests/generate_all_fixtures.rs +++ b/tests/sqlx/tests/generate_all_fixtures.rs @@ -40,6 +40,14 @@ async fn generate_all() -> anyhow::Result<()> { eql_tests::fixtures::v3_ste_vec::generate().await?; eprintln!("Regenerated v3_ste_vec."); + // The storage-only / encryption-only json fixture (CIP-3512) — a + // hand-written `FixtureSpec` with NO index, so each + // document encrypts to a plain `{v, i, c}` envelope for the storage-only + // `public.eql_v3_json` domain. Same pipeline, no SteVec index. + eprintln!("Generating fixture v3_json_storage (storage-only json)..."); + eql_tests::fixtures::v3_json_storage::generate().await?; + eprintln!("Regenerated v3_json_storage."); + // The scalar-shaped SteVec document fixture — one `{"field": }` // document per `eql_domains::INTEGER_VALUES`, with an integer plaintext oracle — // drives the jsonb-entry behaviour matrix. Same pipeline, split payload diff --git a/tests/sqlx/tests/v3_json_storage_tests.rs b/tests/sqlx/tests/v3_json_storage_tests.rs new file mode 100644 index 000000000..27580fa2e --- /dev/null +++ b/tests/sqlx/tests/v3_json_storage_tests.rs @@ -0,0 +1,94 @@ +//! The storage-only / encryption-only `public.eql_v3_json` domain (CIP-3512). +//! +//! Ties the generated `eql_bindings::v3::json::Json` binding to REAL cipherstash +//! crypto and to the generated `public.eql_v3_json` domain CHECK + native-jsonb +//! operator firewall (both materialized under `src/v3/scalars/json/`) +//! simultaneously. The fixture (`fixtures.v3_json_storage`, column +//! `payload public.eql_v3_json`) is GENERATED by encrypting JSON documents with +//! NO index (`mise run fixture:generate:all`), so each payload is a real +//! `{v, i, c}` envelope the domain CHECK validated at INSERT — not a +//! hand-written literal. + +use eql_bindings::v3::json::Json; +use sqlx::PgPool; + +#[sqlx::test(fixtures(path = "../fixtures", scripts("v3_json_storage")))] +async fn real_storage_only_row_parses_into_the_json_binding(pool: PgPool) -> anyhow::Result<()> { + let payload: serde_json::Value = sqlx::query_scalar( + "SELECT payload::jsonb FROM fixtures.v3_json_storage ORDER BY id LIMIT 1", + ) + .fetch_one(&pool) + .await?; + + // A storage-only payload is a plain ciphertext envelope: v/i/c, and NO + // SteVec structure (`sv`) or form discriminator (`k`). + let obj = payload.as_object().expect("payload is an object"); + assert_eq!(obj.get("v"), Some(&serde_json::json!(3))); + assert!( + obj.contains_key("i"), + "storage payload carries index metadata" + ); + assert!( + obj.contains_key("c"), + "storage payload carries a ciphertext" + ); + assert!( + !obj.contains_key("sv"), + "storage payload has no SteVec array" + ); + + // The real wire shape parses into the generated strict `Json` binding + // (rejects unknown keys / a wrong envelope version). + let _typed: Json = serde_json::from_value(payload)?; + Ok(()) +} + +#[sqlx::test(fixtures(path = "../fixtures", scripts("v3_json_storage")))] +async fn storage_only_domain_blocks_native_jsonb_operators(pool: PgPool) -> anyhow::Result<()> { + // The storage-only domain supports NO eql operators — the native-jsonb + // firewall raises rather than letting a query silently operate on the raw + // envelope. Containment against a real fixture row must error. + let err = sqlx::query_scalar::<_, bool>( + "SELECT payload @> '{}'::jsonb FROM fixtures.v3_json_storage LIMIT 1", + ) + .fetch_one(&pool) + .await + .expect_err("@> on a storage-only json column must raise"); + assert!( + err.to_string().contains("not supported"), + "expected an 'operator not supported' firewall error, got: {err}" + ); + Ok(()) +} + +#[sqlx::test(fixtures(path = "../fixtures", scripts("v3_json_storage")))] +async fn storage_and_search_domain_checks_are_mutually_exclusive( + pool: PgPool, +) -> anyhow::Result<()> { + // A real storage payload ({v,i,c}) is accepted by public.eql_v3_json but + // REJECTED by the searchable document domain (which requires an `sv` array). + let storage: serde_json::Value = sqlx::query_scalar( + "SELECT payload::jsonb FROM fixtures.v3_json_storage ORDER BY id LIMIT 1", + ) + .fetch_one(&pool) + .await?; + + // Accepted by the storage domain (round-trips through its CHECK). + let ok: bool = sqlx::query_scalar("SELECT ($1::jsonb::public.eql_v3_json) IS NOT NULL") + .bind(&storage) + .fetch_one(&pool) + .await?; + assert!(ok, "storage payload must cast to public.eql_v3_json"); + + // Rejected by the searchable document domain — no `sv` array. + let rejected = + sqlx::query_scalar::<_, bool>("SELECT ($1::jsonb::public.eql_v3_json_search) IS NOT NULL") + .bind(&storage) + .fetch_one(&pool) + .await; + assert!( + rejected.is_err(), + "a storage {{v,i,c}} payload must NOT cast to the searchable document domain" + ); + Ok(()) +} From e73f6f684cf8014a793fc398c7dd14ce2b5ca8af Mon Sep 17 00:00:00 2001 From: Toby Hede Date: Wed, 15 Jul 2026 12:11:31 +1000 Subject: [PATCH 05/19] =?UTF-8?q?test(json):=20storage-only=20eql=5Fv3=5Fj?= =?UTF-8?q?son=20domain=20=E2=80=94=20real-ciphertext=20matrix=20parity?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bring the storage-only public.eql_v3_json suite to parity with boolean's caps=[storage] matrix arm, over the real v3_json_storage fixture, and remove the synthetic duplication left behind by the first pass (89a1da5c). v3_json_storage_tests (3 -> 9 tests), mirroring tests/sqlx/src/matrix.rs: - storage_fixture_shape: {v,i,c} with no sv/k and no term keys (hm/ob/bf/op); real wire shape parses into the generated Json binding. - storage_comparison_blockers: = <> < <= > >= @> <@ raise, both operand orders. - storage_path_op_blockers: explicitly-typed -> / ->> raise. - storage_native_jsonb_blockers: ? ?| ?& @? @@ #> #>> - #- || raise. - storage_native_absent_ops: ~~ / ~~* -> "operator does not exist". - storage_aggregate_typecheck: eql_v3.min/max must not resolve; asserts on SQLSTATE 42883 (undefined_function) or 42725 (ambiguous_function), exactly as matrix_boolean_storage_aggregate_typecheck does. - storage_path_operators_unknown_literal_fall_through: with an UNKNOWN-type literal RHS, -> / ->> / ? resolve to native jsonb (plaintext-safe) instead of the domain blocker. Documents that resolution turns on literal typing alone; the blocked, explicitly-typed forms are storage_path_op_blockers. - storage_row_count, storage_and_search_domain_checks_are_mutually_exclusive. Two behaviours pinned by probing the real surface, not assumed: - Path-op resolution on public.eql_v3_json is literal-typing dependent — an exact-match domain blocker beats the base-type jsonb operator only when the RHS type is known; an unknown literal falls through. Both are pinned. - eql_v3.min/max(eql_v3_json) errors 42725 (ambiguous_function) because the jsonb-backed value coerces equally to the many ordered-domain min/max overloads, none specific to storage. Asserting on SQLSTATE (not the message) makes this a stable proof the storage domain owns no aggregate — the same 42883-or-42725 contract the boolean matrix driver uses. jsonb_check.rs: delete the two synthetic storage tests now covered by real fixtures (blocks_native_comparison_operators, path_operators_fall_through); rename the malformed-corpus test to json_storage_check_rejects_malformed and drop its positive {v,i,c} accept rows (acceptance is proven by the fixture loading through the CHECK at INSERT and by storage_fixture_shape). Test-only; no SQL/catalog/bindings change, no changeset. --- .../encrypted_domain/family/jsonb_check.rs | 120 +------ tests/sqlx/tests/v3_json_storage_tests.rs | 310 +++++++++++++++--- 2 files changed, 287 insertions(+), 143 deletions(-) diff --git a/tests/sqlx/tests/encrypted_domain/family/jsonb_check.rs b/tests/sqlx/tests/encrypted_domain/family/jsonb_check.rs index 6e6da670f..96c7fe39b 100644 --- a/tests/sqlx/tests/encrypted_domain/family/jsonb_check.rs +++ b/tests/sqlx/tests/encrypted_domain/family/jsonb_check.rs @@ -158,20 +158,24 @@ async fn storage_cast_accepts(pool: &PgPool, payload: Option<&str>) -> Result Result<()> { +async fn json_storage_check_rejects_malformed(pool: PgPool) -> Result<()> { let candidates: &[(Option<&str>, bool)] = &[ - // SQL NULL — a domain accepts NULL (no CHECK is evaluated). + // SQL NULL — a domain accepts NULL (no CHECK is evaluated). The one + // non-rejection, kept as the boundary case: NULL is not "malformed". (None, true), - // Valid: the minimal `{v,i,c}` envelope; extra keys allowed. - (Some(r#"{"v":"3","i":{},"c":"ct"}"#), true), - ( - Some(r#"{"v":"3","i":{"t":"tbl","c":"col"},"c":"ct","extra":1}"#), - true, - ), // Invalid: a SteVec document (`sv`, no root `c`) — belongs to // public.eql_v3_json_search, not the ciphertext-only storage domain. ( @@ -200,100 +204,6 @@ async fn json_storage_check_accepts_envelope_rejects_malformed(pool: PgPool) -> Ok(()) } -/// The comparison/containment native jsonb operators are BLOCKED on -/// `public.eql_v3_json`: a value typed as the storage domain can never fall -/// through to plaintext-jsonb equality/containment. Each raises -/// `... is not supported ...` (a LANGUAGE plpgsql blocker the planner cannot -/// elide). NB: the pure path/existence operators (`->`, `->>`, `?`) resolve to -/// native jsonb on ANY jsonb-backed storage domain (`eql_v3_integer` included) — -/// a pre-existing PostgreSQL operator-resolution quirk, not specific to `json` -/// — so they are deliberately not asserted here. -#[sqlx::test] -async fn json_storage_blocks_native_comparison_operators(pool: PgPool) -> Result<()> { - let envelope = r#"{"v":"3","i":{},"c":"ct"}"#; - let ops: &[&str] = &[ - "col = '{}'::jsonb", - "col @> '{}'::jsonb", - "col <@ '{}'::jsonb", - "col #> '{k}'::text[]", - "col || '{}'::jsonb", - ]; - for frag in ops { - let sql = format!("SELECT {frag} FROM (SELECT $1::public.eql_v3_json AS col) t"); - let err = sqlx::query_scalar::<_, serde_json::Value>(&sql) - .bind(envelope) - .fetch_one(&pool) - .await - .expect_err(&format!( - "native jsonb operator in `{frag}` must be blocked" - )); - anyhow::ensure!( - err.to_string().contains("is not supported"), - "expected a 'not supported' blocker error for `{frag}`, got: {err}" - ); - } - Ok(()) -} - -/// KNOWN LIMITATION (characterization test — pins current behaviour, there is no -/// fix). The pure path/existence native jsonb operators `->`, `->>`, and `?` are -/// NOT blocked on `public.eql_v3_json`: they resolve to the native `jsonb` -/// operator and return a plaintext result (`NULL` / `false`) instead of raising -/// the blocker. This is a PostgreSQL operator-resolution quirk affecting EVERY -/// jsonb-backed storage domain (`eql_v3_integer`, `eql_v3_boolean`, … — not -/// specific to `json`): for these operators the planner binds the base-type -/// `jsonb` operator rather than the domain-specific blocker. The -/// comparison/containment operators (`=`, `@>`, `<@`, `#>`, `||`) DO engage the -/// blocker — see `json_storage_blocks_native_comparison_operators`. -/// -/// The encrypted ciphertext lives in `c`, so `->'c'` / `->>'c'` merely echo the -/// already-opaque ciphertext string and `?` tests key presence in the envelope — -/// none of which leaks plaintext. This test exists so that if a future -/// PostgreSQL version (or an EQL change) starts routing these through the -/// blocker, the change is noticed here rather than silently altering behaviour. -#[sqlx::test] -async fn json_storage_path_operators_fall_through_to_native_known_limitation( - pool: PgPool, -) -> Result<()> { - let envelope = r#"{"v":"3","i":{},"c":"ct"}"#; - let of = |frag: &str| format!("SELECT {frag} FROM (SELECT $1::public.eql_v3_json AS col) t"); - - // `->` / `->>` return native jsonb: NULL for an absent key, and `-> 'c'` - // echoes the (already-opaque) ciphertext string — no plaintext leak. None raise. - let jsonb_cases: &[(&str, serde_json::Value)] = &[ - ("col -> 'missing'", serde_json::Value::Null), - ("col ->> 'missing'", serde_json::Value::Null), - ("col -> 'c'", serde_json::json!("ct")), - ]; - for (frag, expected) in jsonb_cases { - let got: Option = sqlx::query_scalar(&of(frag)) - .bind(envelope) - .fetch_one(&pool) - .await - .unwrap_or_else(|e| panic!("`{frag}` unexpectedly raised (limitation changed?): {e}")); - let got = got.unwrap_or(serde_json::Value::Null); - anyhow::ensure!( - &got == expected, - "path operator `{frag}` returned {got:?}, expected native {expected:?}" - ); - } - - // `?` tests envelope key presence and returns a native boolean (does not raise). - let key_cases: &[(&str, bool)] = &[("col ? 'c'", true), ("col ? 'absent'", false)]; - for (frag, expected) in key_cases { - let got: bool = sqlx::query_scalar(&of(frag)) - .bind(envelope) - .fetch_one(&pool) - .await - .unwrap_or_else(|e| panic!("`{frag}` unexpectedly raised (limitation changed?): {e}")); - anyhow::ensure!( - got == *expected, - "existence operator `{frag}` returned {got}, expected native {expected}" - ); - } - Ok(()) -} - /// The query_json validator must stay plpgsql: its only caller is the domain /// CHECK (a context that can never inline a SQL function), so LANGUAGE sql /// pays the per-call SQL-function executor on every containment-needle cast diff --git a/tests/sqlx/tests/v3_json_storage_tests.rs b/tests/sqlx/tests/v3_json_storage_tests.rs index 27580fa2e..91992e79d 100644 --- a/tests/sqlx/tests/v3_json_storage_tests.rs +++ b/tests/sqlx/tests/v3_json_storage_tests.rs @@ -1,72 +1,306 @@ -//! The storage-only / encryption-only `public.eql_v3_json` domain (CIP-3512). +//! Real-ciphertext coverage for the storage-only / encryption-only +//! `public.eql_v3_json` domain (CIP-3512) — the json analogue of boolean's +//! `caps=[storage]` matrix arm. //! -//! Ties the generated `eql_bindings::v3::json::Json` binding to REAL cipherstash -//! crypto and to the generated `public.eql_v3_json` domain CHECK + native-jsonb -//! operator firewall (both materialized under `src/v3/scalars/json/`) -//! simultaneously. The fixture (`fixtures.v3_json_storage`, column -//! `payload public.eql_v3_json`) is GENERATED by encrypting JSON documents with -//! NO index (`mise run fixture:generate:all`), so each payload is a real -//! `{v, i, c}` envelope the domain CHECK validated at INSERT — not a -//! hand-written literal. +//! `json` cannot ride the `scalar_matrix!` machinery (its family is non-scalar +//! because of the SteVec domains), so this hand-written suite mirrors the +//! boolean storage matrix's coverage set over a REAL fixture: +//! `fixtures.v3_json_storage` (column `payload public.eql_v3_json`) is GENERATED +//! by encrypting JSON documents with NO index (`mise run fixture:generate:all`), +//! so every payload is a real `{v, i, c}` envelope the domain CHECK validated at +//! INSERT — never a hand-written literal. +//! +//! Coverage, mirroring the boolean storage arm (`tests/sqlx/src/matrix.rs`): +//! - `storage_fixture_shape` ~ `matrix_boolean_storage_fixture_shape` +//! - `storage_comparison_blockers`~ `matrix_boolean_storage__blocker` +//! - `storage_path_op_blockers` ~ `matrix_boolean_storage_path_op_blockers` +//! - `storage_native_jsonb_blockers` ~ `matrix_*_native_jsonb_blockers` +//! - `storage_native_absent_ops` ~ `matrix_boolean_storage_native_absent_ops` +//! - `storage_aggregate_typecheck`~ `matrix_boolean_storage_aggregate_typecheck_{min,max}` +//! - `storage_row_count` ~ `matrix_boolean_storage_count` +//! plus two json-specific tests with no scalar analogue: the `Json` binding +//! parse, and the storage/search domain mutual-exclusion. +//! +//! `storage_aggregate_typecheck` asserts on the SQLSTATE, not the message text — +//! exactly as the boolean driver does — so the "function is not unique" +//! ambiguity (42725) it hits is a stable, meaningful proof that the storage +//! domain owns no aggregate, not a brittle string match. See that test's doc. +//! +//! ## Operator resolution depends on literal typing (load-bearing) +//! +//! The firewall blockers are exact-match operators `(, public.eql_v3_json, +//! )`. PostgreSQL prefers an exact-match operator over walking the +//! domain up to its `jsonb` base type — but ONLY when the RHS type is known. +//! With an *unknown-type* literal (`payload -> 'c'`, no `::text`), the base-type +//! `jsonb -> text` wins and the call falls through to native jsonb. With an +//! explicitly-typed operand (`payload -> 'c'::text`) the domain blocker engages +//! and raises. `storage_path_op_blockers` pins the blocked (explicit) form; +//! `storage_path_operators_unknown_literal_fall_through` pins the fall-through +//! (unknown-literal) form and documents that the two differ only by literal +//! typing. Both are real behaviours of the current generated surface. use eql_bindings::v3::json::Json; use sqlx::PgPool; +/// Number of fixture rows — mirrors `ROW_COUNT` in +/// `tests/sqlx/src/fixtures/v3_json_storage.rs` (not importable from a test +/// binary, so pinned here; `storage_row_count` fails loudly if they drift). +const ROW_COUNT: i64 = 3; + +/// Assert `sql` raises the EQL "operator ... is not supported" blocker. +async fn assert_blocks(pool: &PgPool, sql: &str) -> anyhow::Result<()> { + match sqlx::query(sql).fetch_optional(pool).await { + Ok(_) => anyhow::bail!("expected the firewall blocker, but `{sql}` succeeded"), + Err(e) => { + let s = e.to_string(); + anyhow::ensure!( + s.contains("is not supported"), + "expected an 'is not supported' blocker for `{sql}`, got: {s}" + ); + Ok(()) + } + } +} + +/// Assert `sql` fails with PostgreSQL's "operator does not exist" — the operator +/// is neither declared on the domain nor resolvable via the base type. +async fn assert_no_operator(pool: &PgPool, sql: &str) -> anyhow::Result<()> { + match sqlx::query(sql).fetch_optional(pool).await { + Ok(_) => anyhow::bail!("expected 'operator does not exist', but `{sql}` succeeded"), + Err(e) => { + let s = e.to_string(); + anyhow::ensure!( + s.contains("does not exist"), + "expected 'operator does not exist' for `{sql}`, got: {s}" + ); + Ok(()) + } + } +} + +/// A real storage-only row is a `{v, i, c}` ciphertext envelope with NO SteVec +/// structure (`sv`/`k`) and NO index-term keys (`hm`/`ob`/`bf`/`op`), and the +/// real wire shape parses into the generated strict `Json` binding. +/// +/// Mirrors `matrix_boolean_storage_fixture_shape` (structural payload check), +/// plus the json-specific binding-parse that has no scalar analogue. #[sqlx::test(fixtures(path = "../fixtures", scripts("v3_json_storage")))] -async fn real_storage_only_row_parses_into_the_json_binding(pool: PgPool) -> anyhow::Result<()> { +async fn storage_fixture_shape(pool: PgPool) -> anyhow::Result<()> { let payload: serde_json::Value = sqlx::query_scalar( "SELECT payload::jsonb FROM fixtures.v3_json_storage ORDER BY id LIMIT 1", ) .fetch_one(&pool) .await?; - // A storage-only payload is a plain ciphertext envelope: v/i/c, and NO - // SteVec structure (`sv`) or form discriminator (`k`). let obj = payload.as_object().expect("payload is an object"); - assert_eq!(obj.get("v"), Some(&serde_json::json!(3))); - assert!( - obj.contains_key("i"), - "storage payload carries index metadata" - ); - assert!( - obj.contains_key("c"), - "storage payload carries a ciphertext" - ); - assert!( - !obj.contains_key("sv"), - "storage payload has no SteVec array" - ); + assert_eq!(obj.get("v"), Some(&serde_json::json!(3)), "envelope version"); + assert!(obj.contains_key("i"), "storage payload carries index metadata"); + assert!(obj.contains_key("c"), "storage payload carries a ciphertext"); + // Storage-only: no SteVec array / form discriminator, and — crucially — no + // index-term keys, because nothing is searchable. + for absent in ["sv", "k", "hm", "ob", "bf", "op"] { + assert!( + !obj.contains_key(absent), + "storage payload must not carry `{absent}` (found in {obj:?})" + ); + } // The real wire shape parses into the generated strict `Json` binding - // (rejects unknown keys / a wrong envelope version). + // (which rejects unknown keys / a wrong envelope version). let _typed: Json = serde_json::from_value(payload)?; Ok(()) } +/// Every comparison and containment operator raises the firewall on a REAL +/// fixture row — a storage-only value can never fall through to plaintext-jsonb +/// equality/containment. Sweeps the `(domain, jsonb)` and `(jsonb, domain)` +/// overloads. Mirrors `matrix_boolean_storage__blocker`. #[sqlx::test(fixtures(path = "../fixtures", scripts("v3_json_storage")))] -async fn storage_only_domain_blocks_native_jsonb_operators(pool: PgPool) -> anyhow::Result<()> { - // The storage-only domain supports NO eql operators — the native-jsonb - // firewall raises rather than letting a query silently operate on the raw - // envelope. Containment against a real fixture row must error. - let err = sqlx::query_scalar::<_, bool>( - "SELECT payload @> '{}'::jsonb FROM fixtures.v3_json_storage LIMIT 1", +async fn storage_comparison_blockers(pool: PgPool) -> anyhow::Result<()> { + const FROM: &str = "FROM fixtures.v3_json_storage LIMIT 1"; + for op in ["=", "<>", "<", "<=", ">", ">=", "@>", "<@"] { + // (domain, jsonb) and (jsonb, domain) — both overloads must engage. + assert_blocks(&pool, &format!("SELECT payload {op} '{{}}'::jsonb {FROM}")).await?; + assert_blocks(&pool, &format!("SELECT '{{}}'::jsonb {op} payload {FROM}")).await?; + } + Ok(()) +} + +/// The JSON path/subscript operators `->` / `->>` raise the firewall on a real +/// row when the operand is explicitly typed (`'field'::text`, `0::integer`), and +/// in the reversed `(jsonb, domain)` shape. Mirrors +/// `matrix_boolean_storage_path_op_blockers`. +/// +/// NB: an *unknown*-type literal RHS (`payload -> 'field'`) resolves to native +/// jsonb instead — characterised separately in +/// `storage_path_operators_unknown_literal_fall_through`. +#[sqlx::test(fixtures(path = "../fixtures", scripts("v3_json_storage")))] +async fn storage_path_op_blockers(pool: PgPool) -> anyhow::Result<()> { + const FROM: &str = "FROM fixtures.v3_json_storage LIMIT 1"; + for op in ["->", "->>"] { + assert_blocks(&pool, &format!("SELECT payload {op} 'field'::text {FROM}")).await?; + assert_blocks(&pool, &format!("SELECT payload {op} 0::integer {FROM}")).await?; + assert_blocks(&pool, &format!("SELECT '{{}}'::jsonb {op} payload {FROM}")).await?; + } + Ok(()) +} + +/// The residual native-jsonb operators the codegen firewall blocks on the +/// storage domain — existence (`? ?| ?&`), path-array (`#> #>>`), jsonpath +/// (`@? @@`), delete (`- #-`), and concat (`||`) — each raise on a real row with +/// explicitly-typed operands. Mirrors the `native_jsonb_blockers` matrix arm +/// (`NATIVE_JSONB_BLOCKER_ARM_SYMBOLS`); `#>` / `||` are the subset the plan +/// called out explicitly. +#[sqlx::test(fixtures(path = "../fixtures", scripts("v3_json_storage")))] +async fn storage_native_jsonb_blockers(pool: PgPool) -> anyhow::Result<()> { + const FROM: &str = "FROM fixtures.v3_json_storage LIMIT 1"; + let single = [ + "payload ? 'c'::text", + "payload ?| ARRAY['c']", + "payload ?& ARRAY['c']", + "payload #> ARRAY['i']", + "payload #>> ARRAY['i', 'c']", + "payload @? '$.c'::jsonpath", + "payload @@ '$.c == \"x\"'::jsonpath", + "payload - 'c'::text", + "payload - 0", + "payload - ARRAY['c']", + "payload #- ARRAY['i']", + ]; + for expr in single { + assert_blocks(&pool, &format!("SELECT {expr} {FROM}")).await?; + } + // `||` overloads: (domain, jsonb), (jsonb, domain), (domain, domain). + assert_blocks(&pool, &format!("SELECT payload || '{{}}'::jsonb {FROM}")).await?; + assert_blocks(&pool, &format!("SELECT '{{}}'::jsonb || payload {FROM}")).await?; + assert_blocks( + &pool, + &format!( + "SELECT a.payload || b.payload \ + FROM fixtures.v3_json_storage a, fixtures.v3_json_storage b LIMIT 1" + ), + ) + .await?; + Ok(()) +} + +/// `~~` / `~~*` (LIKE / ILIKE) are not declared on the storage domain and have +/// no jsonb base-type form, so resolution fails with "operator does not exist" +/// rather than the EQL blocker. Mirrors `matrix_boolean_storage_native_absent_ops`. +#[sqlx::test(fixtures(path = "../fixtures", scripts("v3_json_storage")))] +async fn storage_native_absent_ops(pool: PgPool) -> anyhow::Result<()> { + const FROM: &str = "FROM fixtures.v3_json_storage LIMIT 1"; + for op in ["~~", "~~*"] { + assert_no_operator(&pool, &format!("SELECT payload {op} payload {FROM}")).await?; + } + Ok(()) +} + +/// KNOWN, DELIBERATE resolution quirk (characterisation — pins current +/// behaviour). With an UNKNOWN-type literal RHS, `->` / `->>` / `?` resolve to +/// the native `jsonb` base-type operator instead of the domain blocker and +/// return a plaintext-SAFE result: `-> 'c'` / `->> 'c'` echo the already-opaque +/// ciphertext string, `?` tests envelope-key presence — none leaks plaintext. +/// The blocked, explicitly-typed forms are covered by `storage_path_op_blockers`; +/// the ONLY difference is whether the RHS literal carries a type annotation. +/// +/// This affects every jsonb-backed storage domain (`eql_v3_integer`, +/// `eql_v3_boolean`, …), not just json. The test exists so that if a future +/// PostgreSQL version changes operator resolution, the change surfaces here. +#[sqlx::test(fixtures(path = "../fixtures", scripts("v3_json_storage")))] +async fn storage_path_operators_unknown_literal_fall_through(pool: PgPool) -> anyhow::Result<()> { + // `-> 'c'` (unknown literal) returns the ciphertext string as jsonb; an + // absent key returns SQL NULL. Neither raises. + let c_val: Option = sqlx::query_scalar( + "SELECT payload -> 'c' FROM fixtures.v3_json_storage ORDER BY id LIMIT 1", ) .fetch_one(&pool) .await - .expect_err("@> on a storage-only json column must raise"); - assert!( - err.to_string().contains("not supported"), - "expected an 'operator not supported' firewall error, got: {err}" + .map_err(|e| anyhow::anyhow!("`payload -> 'c'` unexpectedly raised (resolution changed?): {e}"))?; + anyhow::ensure!( + matches!(c_val, Some(serde_json::Value::String(_))), + "`payload -> 'c'` should echo the ciphertext string, got {c_val:?}" ); + + let missing: Option = sqlx::query_scalar( + "SELECT payload -> 'missing' FROM fixtures.v3_json_storage ORDER BY id LIMIT 1", + ) + .fetch_one(&pool) + .await?; + anyhow::ensure!(missing.is_none(), "`payload -> 'missing'` should be NULL, got {missing:?}"); + + // `?` (unknown literal) tests envelope-key presence and returns native bool. + let has_c: bool = sqlx::query_scalar( + "SELECT payload ? 'c' FROM fixtures.v3_json_storage ORDER BY id LIMIT 1", + ) + .fetch_one(&pool) + .await?; + anyhow::ensure!(has_c, "`payload ? 'c'` should be true (envelope has a `c` key)"); + + let has_absent: bool = sqlx::query_scalar( + "SELECT payload ? 'absent' FROM fixtures.v3_json_storage ORDER BY id LIMIT 1", + ) + .fetch_one(&pool) + .await?; + anyhow::ensure!(!has_absent, "`payload ? 'absent'` should be false"); + Ok(()) +} + +/// The real rows loaded through the domain CHECK at INSERT — proves the fixture +/// count and that every generated `{v,i,c}` envelope passed the CHECK. Mirrors +/// `matrix_boolean_storage_count`. +#[sqlx::test(fixtures(path = "../fixtures", scripts("v3_json_storage")))] +async fn storage_row_count(pool: PgPool) -> anyhow::Result<()> { + let count: i64 = sqlx::query_scalar("SELECT count(*) FROM fixtures.v3_json_storage") + .fetch_one(&pool) + .await?; + assert_eq!(count, ROW_COUNT, "fixture row count drifted from ROW_COUNT"); + Ok(()) +} + +/// `eql_v3.min` / `max` are NOT available on the storage domain — it carries no +/// ORE term, so no aggregate is defined for it. Mirrors +/// `matrix_boolean_storage_aggregate_typecheck_{min,max}`: the call must FAIL, +/// and asserting on the SQLSTATE (not the message text) makes that stable. +/// +/// Two error codes are both acceptable, and mean the same thing — the domain +/// owns no MIN/MAX of its own: +/// - `42883` undefined_function — no overload resolves at all. +/// - `42725` ambiguous_function — the jsonb-backed value coerces equally to +/// the many ordered-domain overloads (`eql_v3.min(eql_v3_integer_ord)`, +/// `eql_v3.min(eql_v3_json_entry)`, …), none specific to the storage domain, +/// so PostgreSQL picks none ("function is not unique"). This is the code +/// `public.eql_v3_json` actually returns. +/// If the call instead resolved, `expect_err` fails loudly — the guarantee is +/// that a storage-only value can never be aggregated, whatever the mechanism. +#[sqlx::test(fixtures(path = "../fixtures", scripts("v3_json_storage")))] +async fn storage_aggregate_typecheck(pool: PgPool) -> anyhow::Result<()> { + for agg in ["min", "max"] { + let sql = format!("SELECT eql_v3.{agg}(payload) FROM fixtures.v3_json_storage"); + let err = sqlx::query_scalar::<_, serde_json::Value>(&sql) + .fetch_one(&pool) + .await + .expect_err(&format!( + "eql_v3.{agg} must not resolve on the storage-only domain" + )); + let code = err.as_database_error().and_then(|e| e.code()); + anyhow::ensure!( + matches!(code.as_deref(), Some("42883") | Some("42725")), + "expected SQLSTATE 42883 (undefined_function) or 42725 \ + (ambiguous_function) for eql_v3.{agg}(eql_v3_json), got {code:?}: {err}" + ); + } Ok(()) } +/// A real storage payload (`{v,i,c}`) is accepted by `public.eql_v3_json` but +/// REJECTED by the searchable document domain `public.eql_v3_json_search` +/// (which requires an `sv` array) — the structural distinction between the two +/// json domains, over real crypto. #[sqlx::test(fixtures(path = "../fixtures", scripts("v3_json_storage")))] async fn storage_and_search_domain_checks_are_mutually_exclusive( pool: PgPool, ) -> anyhow::Result<()> { - // A real storage payload ({v,i,c}) is accepted by public.eql_v3_json but - // REJECTED by the searchable document domain (which requires an `sv` array). let storage: serde_json::Value = sqlx::query_scalar( "SELECT payload::jsonb FROM fixtures.v3_json_storage ORDER BY id LIMIT 1", ) From a51c1f4f620eb1aeb656d4dd9c5a53e70b106350 Mon Sep 17 00:00:00 2001 From: Toby Hede Date: Wed, 15 Jul 2026 13:41:18 +1000 Subject: [PATCH 06/19] test(json): isolate storage-reject payload + fix identity in clean-install smoke Address review feedback on the clean-install v3 smoke test: - The storage-only negative test cast a `{"v":"3","i":{},"sv":[...]}` payload, which differs from a valid `{v,i,c}` envelope in three ways (string v, empty i, sv-not-c). Rewrite it to integer v=3 + a populated i{t,c} keeping sv and no root c, so the payload differs from a valid storage envelope by exactly the c->sv swap and the storage CHECK's has-c rule is the isolated failure. - The searchable smoke insert's identity object was inverted (`{"c":"v3_json_smoke","t":"encrypted"}`); correct it to `{"t":"v3_json_smoke", "c":"e"}` (t=table, c=column), matching the storage smoke test's format. Validated end to end via tasks/test/clean_install_v3.sh (clean v3 install OK). --- tasks/test/clean_install_v3.sh | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tasks/test/clean_install_v3.sh b/tasks/test/clean_install_v3.sh index 84a46854c..87ef6a50a 100755 --- a/tasks/test/clean_install_v3.sh +++ b/tasks/test/clean_install_v3.sh @@ -75,7 +75,7 @@ echo "==> smoke: v3 searchable encrypted-JSON (SteVec) surface" "${RUN[@]}" <<'SQL' CREATE TABLE v3_json_smoke (id int PRIMARY KEY, e public.eql_v3_json_search); INSERT INTO v3_json_smoke VALUES - (1, '{"i":{"c":"v3_json_smoke","t":"encrypted"},"v":3,"sv":[{"s":"sel","c":"ciphertext","hm":"00"}]}'::public.eql_v3_json_search); + (1, '{"i":{"t":"v3_json_smoke","c":"e"},"v":3,"sv":[{"s":"sel","c":"ciphertext","hm":"00"}]}'::public.eql_v3_json_search); -- Supported typed accessors and containment. SELECT (e -> 'sel'::text)::jsonb ->> 'hm' FROM v3_json_smoke WHERE id = 1; @@ -125,7 +125,7 @@ DECLARE BEGIN -- A SteVec document (sv, no root c) must be rejected by the storage CHECK. BEGIN - PERFORM '{"v":"3","i":{},"sv":[{"s":"sel","hm":"00"}]}'::public.eql_v3_json; + PERFORM '{"v":3,"i":{"t":"v3_json_storage_smoke","c":"e"},"sv":[{"s":"sel","hm":"00"}]}'::public.eql_v3_json; EXCEPTION WHEN check_violation THEN raised := true; END; From bd8af9dac702f22ae597e4ea273ab432c9256ca0 Mon Sep 17 00:00:00 2001 From: Toby Hede Date: Wed, 15 Jul 2026 14:31:13 +1000 Subject: [PATCH 07/19] =?UTF-8?q?docs(codegen):=20fix=20stale=20jsonb?= =?UTF-8?q?=E2=86=92json=20binding=20refs;=20generalize=20mixed-family=20b?= =?UTF-8?q?indings=20seam?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Address review of the JSON storage/search rename: - CLAUDE.md + render_scalar_only_bindings doc comment referenced the pre-rename jsonb.rs/jsonb_storage.rs/Jsonb/&JSONB names; corrected to json.rs/json_storage.rs/Json/&JSON. - render_bindings hardcoded eql_domains::JSON for the mixed-family storage module; replaced with the generic families_with_scalar_domains().filter(|f| !f.is_scalar()) seam so a second mixed family is picked up automatically, mirroring the SQL side. Byte-identical output today (drift check clean). --- CLAUDE.md | 2 +- crates/eql-codegen/src/bindings.rs | 22 ++++++++++++---------- 2 files changed, 13 insertions(+), 11 deletions(-) diff --git a/CLAUDE.md b/CLAUDE.md index 60e448afa..c1abc5dbf 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -67,7 +67,7 @@ This is the **Encrypt Query Language (EQL)** - a PostgreSQL extension for search Adding a scalar encrypted-domain type is one row in the Rust catalog `eql-domains::CATALOG` (`crates/eql-domains/src/lib.rs`): a `DomainFamily` giving the type `name` (e.g. `bigint`), its `ScalarKind` (the `kind` field), the `Domain`s mapping each generated (bare) domain name to its fixed index `Term`s (`eq => [Hm]`, `ord`/`ord_ore => [Ore]`), and the `Fixture` value list. Term capabilities are fixed in the `Term` enum's `impl` methods (with unit tests): `Hm` provides equality, and `Ore` provides equality plus ordering. There is no TOML manifest and no Python — the catalog is the source of truth, validated by the compiler (an undefined term or unknown scalar is a compile error) plus catalog `#[test]`s. `mise run build` runs `cargo run -p eql-codegen`, which regenerates the scalar SQL surface into `src/v3/scalars//` from `CATALOG` at the start of every build; that surface includes supported comparison wrappers plus blockers for native `json` operators that would otherwise be reachable through domain fallback. `cargo run -p eql-codegen` regenerates every type at once (the same call `mise run build` uses; there is no per-type codegen task). The generated `*_types.sql` / `*_functions.sql` / `*_operators.sql` / `*_aggregates.sql` files are **committed in place** under `src/v3/scalars//` and drift-gated by `mise run codegen:parity` (regenerate in place + `git diff` + untracked check — the same regenerate-and-diff pattern `types:check` uses for the committed bindings). They are still machine-generated: change the catalog and rebuild, never hand-edit (CI fails on drift). The per-type plaintext fixture lists the SQLx matrix consumes are **not** a generated file — they are materialised from each `CATALOG` row at compile time as `eql_domains::INT4_VALUES` / `INT2_VALUES` (the `int_values!` macro) and read directly by `ScalarType::FIXTURE_VALUES`; a Rust source of truth no longer round-trips through a committed generated `.rs`. Generated SQL carries a `-- AUTOMATICALLY GENERATED FILE` header (the project-wide marker `docs:validate` greps on); change the catalog and rebuild, never hand-edit. Hand-written SQL beyond the fixed surface goes in `src/v3/scalars//_extensions.sql` with no auto-generated header and explicit `-- REQUIRE:` edges — that file IS committed. `json`'s **SteVec** domains never enter this pipeline, but its **scalar storage domain does**: `generate_all` iterates `eql_domains::families_with_scalar_domains()` and renders each family's scalar domains (so `public.eql_v3_json` is generated into `src/v3/scalars/json/`), while `list-types` and the SQLx matrix still iterate `eql_domains::scalar_families()`, which excludes the whole non-scalar `json` family — so `json` stays out of the operator/coverage matrix by construction (a storage-only domain carries no operator matrix), even though its ciphertext-only storage domain now has a generated SQL surface. -The same generator also emits the **Rust payload bindings** under `crates/eql-bindings/src/v3/.rs` (structs + `DomainType` impls) and the `inventory.rs` `all()` list, from the same `CATALOG` — committed with a `// @generated` header (the bindings must exist on a clean clone because `ts-rs`/`schemars` derive the committed TypeScript/JSON Schema off them; the SQL surface is now committed too, so both generated targets are handled consistently — committed in place, drift-gated by regenerate-and-`git diff`). The hand-written `DomainType` trait, the shared newtypes (`SchemaVersion`/`Identifier`/`Ciphertext`/`Hmac256`/`OreBlock256`/`BloomFilter`), the `PhantomData` plumbing, and the architectural module doc (including the non-derivable float-NaN and bool storage-only caveats) stay hand-written in `crates/eql-bindings/src/v3/{mod,domain_type,terms}.rs`. Generated structs carry a catalog-derived struct doc — a summary line (`` `eql_v3.` — . ``) plus a detail line listing the supported operators and required payload keys, all derived from data the catalog already holds (the capability label, `Term::operators_for_terms`, and `ENVELOPE_KEYS` ++ `Term::term_json_keys` — see `struct_doc_lines` in `crates/eql-codegen/src/bindings.rs`). The required-key list makes structural distinctions visible — e.g. `text_ord` lists `` `v` `i` `c` `hm` `ob` `` (dual-term) versus an integer `integer_ord`'s `` `v` `i` `c` `ob` ``. There are **no per-field docs**: per-field/term semantics live on the shared term newtypes (`terms.rs`, flowing into the TS term files and JSON Schema `$defs`), and non-derivable per-family caveats (float-NaN, bool storage-only) in `mod.rs`. Free-form prose belongs at the **struct level** (a future optional catalog `doc` field emitted as extra `#[doc]` lines), never as per-field docs. JSON Schemas are emitted by **schemars 1.x** as JSON Schema 2020-12. `mise run types:generate` regenerates the Rust bindings (via `eql-codegen bindings`) then the TS/JSON; `mise run types:check` is the committed-reference drift gate — it regenerates and `git diff`s all three (`crates/eql-bindings/src/v3` + `bindings/` + `schema/`), the same regenerate-and-diff pattern `codegen:parity` now uses for the committed SQL surface. Both gates run in CI; `mise run install-hooks` wires a pre-commit hook that runs both locally whenever a commit touches the catalog, the generator, or a committed generated surface. The `json` family's **SteVec** structs (`SteVecDocument`/`SteVecEntry`/`SteVecQuery`, plus the shared `SteVecTerm`/`SteVecQueryEntry`/`OreCllw`/`Selector` newtypes) are hand-written for the same reason as their SQL — in `crates/eql-bindings/src/v3/jsonb.rs`, symmetric with `src/v3/json/` — their field layout (`#[serde(flatten)]`, an `Option` array marker, per-struct serde strictness) isn't derivable from the catalog the way a flat scalar struct is. The family's scalar storage struct **is** generated (a flat `{v,i,c}` struct, `Jsonb`), via `render_scalar_only_bindings(&JSONB)` into `crates/eql-bindings/src/v3/jsonb_storage.rs`; the hand-written `jsonb.rs` re-exports it (`pub use crate::v3::jsonb_storage::Jsonb;`) so `super::jsonb::Jsonb` resolves for the generated inventory/payload. Only inventory membership and ordering are catalog-driven: `inventory.rs::all()` iterates the full `CATALOG` (not `scalar_families()`), branching on `Shape` to include the three SteVec structs plus the generated `Jsonb` alongside the other scalar structs. +The same generator also emits the **Rust payload bindings** under `crates/eql-bindings/src/v3/.rs` (structs + `DomainType` impls) and the `inventory.rs` `all()` list, from the same `CATALOG` — committed with a `// @generated` header (the bindings must exist on a clean clone because `ts-rs`/`schemars` derive the committed TypeScript/JSON Schema off them; the SQL surface is now committed too, so both generated targets are handled consistently — committed in place, drift-gated by regenerate-and-`git diff`). The hand-written `DomainType` trait, the shared newtypes (`SchemaVersion`/`Identifier`/`Ciphertext`/`Hmac256`/`OreBlock256`/`BloomFilter`), the `PhantomData` plumbing, and the architectural module doc (including the non-derivable float-NaN and bool storage-only caveats) stay hand-written in `crates/eql-bindings/src/v3/{mod,domain_type,terms}.rs`. Generated structs carry a catalog-derived struct doc — a summary line (`` `eql_v3.` — . ``) plus a detail line listing the supported operators and required payload keys, all derived from data the catalog already holds (the capability label, `Term::operators_for_terms`, and `ENVELOPE_KEYS` ++ `Term::term_json_keys` — see `struct_doc_lines` in `crates/eql-codegen/src/bindings.rs`). The required-key list makes structural distinctions visible — e.g. `text_ord` lists `` `v` `i` `c` `hm` `ob` `` (dual-term) versus an integer `integer_ord`'s `` `v` `i` `c` `ob` ``. There are **no per-field docs**: per-field/term semantics live on the shared term newtypes (`terms.rs`, flowing into the TS term files and JSON Schema `$defs`), and non-derivable per-family caveats (float-NaN, bool storage-only) in `mod.rs`. Free-form prose belongs at the **struct level** (a future optional catalog `doc` field emitted as extra `#[doc]` lines), never as per-field docs. JSON Schemas are emitted by **schemars 1.x** as JSON Schema 2020-12. `mise run types:generate` regenerates the Rust bindings (via `eql-codegen bindings`) then the TS/JSON; `mise run types:check` is the committed-reference drift gate — it regenerates and `git diff`s all three (`crates/eql-bindings/src/v3` + `bindings/` + `schema/`), the same regenerate-and-diff pattern `codegen:parity` now uses for the committed SQL surface. Both gates run in CI; `mise run install-hooks` wires a pre-commit hook that runs both locally whenever a commit touches the catalog, the generator, or a committed generated surface. The `json` family's **SteVec** structs (`SteVecDocument`/`SteVecEntry`/`SteVecQuery`, plus the shared `SteVecTerm`/`SteVecQueryEntry`/`OreCllw`/`Selector` newtypes) are hand-written for the same reason as their SQL — in `crates/eql-bindings/src/v3/json.rs`, symmetric with `src/v3/json/` — their field layout (`#[serde(flatten)]`, an `Option` array marker, per-struct serde strictness) isn't derivable from the catalog the way a flat scalar struct is. The family's scalar storage struct **is** generated (a flat `{v,i,c}` struct, `Json`), via `render_scalar_only_bindings(&JSON)` into `crates/eql-bindings/src/v3/json_storage.rs`; the hand-written `json.rs` re-exports it (`pub use crate::v3::json_storage::Json;`) so `super::json::Json` resolves for the generated inventory/payload. Only inventory membership and ordering are catalog-driven: `inventory.rs::all()` iterates the full `CATALOG` (not `scalar_families()`), branching on `Shape` to include the three SteVec structs plus the generated `Json` alongside the other scalar structs. **Adding a new encrypted-domain type: follow `docs/reference/adding-a-scalar-encrypted-domain-type.md`.** The mechanics are fixed for ordered scalar domains; the catalog row only declares the name, kind, bare domain names, and terms. New term behavior belongs in the `Term` enum's `impl` methods in `crates/eql-domains/src` with tests, not in free-form catalog data. diff --git a/crates/eql-codegen/src/bindings.rs b/crates/eql-codegen/src/bindings.rs index 1a8ee339a..757d8e403 100644 --- a/crates/eql-codegen/src/bindings.rs +++ b/crates/eql-codegen/src/bindings.rs @@ -326,14 +326,14 @@ pub fn render_family_bindings(family: &DomainFamily) -> String { } /// Render a bindings module for the **scalar domains only** of a mixed family — -/// currently just `jsonb` (its bare `public.eql_v3_json` storage struct). A +/// currently just `json` (its bare `public.eql_v3_json` storage struct). A /// filtered twin of [`render_family_bindings`]: the SteVec domains' structs stay /// hand-written in `json.rs` (their fields/serde aren't catalog-derivable), so /// this must skip them or it would emit clashing/incorrect struct bodies. The /// output is written to `_storage.rs` (e.g. `json_storage.rs`), NOT /// `.rs`, so it never clobbers the hand-written module — the hand-written -/// `json.rs` re-exports the generated struct (`pub use ...::Jsonb;`) so -/// `super::json::Jsonb` resolves for the inventory/payload renderers. +/// `json.rs` re-exports the generated struct (`pub use ...::Json;`) so +/// `super::json::Json` resolves for the inventory/payload renderers. pub fn render_scalar_only_bindings(family: &DomainFamily) -> String { let mut used: Vec<&'static str> = vec!["Ciphertext"]; for d in family.domains.iter().filter(|d| d.is_scalar()) { @@ -738,14 +738,16 @@ fn render_bindings(dir: &Path) -> Vec<(PathBuf, String)> { ) }) .collect(); - // Mixed families (jsonb) are excluded from `scalar_families()`, so their - // scalar storage domain(s) render into a separate `_storage.rs` - // module — the SteVec `.rs` stays hand-written. Guarded so a family - // with no scalar domain emits nothing. - if eql_domains::JSON.domains.iter().any(|d| d.is_scalar()) { + // Mixed families (a family with ≥1 scalar domain that is not wholly scalar — + // `json` today) are excluded from `scalar_families()`, so their scalar + // storage domain(s) render into a separate `_storage.rs` module while + // the SteVec `.rs` stays hand-written. Derived from the same generic + // `families_with_scalar_domains()` seam the SQL materializer iterates rather + // than naming a family, so a second mixed family is picked up automatically. + for f in eql_domains::families_with_scalar_domains().filter(|f| !f.is_scalar()) { rendered.push(( - dir.join(format!("{}_storage.rs", eql_domains::JSON.name)), - render_scalar_only_bindings(&eql_domains::JSON), + dir.join(format!("{}_storage.rs", f.name)), + render_scalar_only_bindings(f), )); } rendered.push((dir.join("payload.rs"), render_payload_rs())); From 920ce735a8bbb040de2c65f1493e4618cac7b387 Mon Sep 17 00:00:00 2001 From: Toby Hede Date: Wed, 15 Jul 2026 14:41:20 +1000 Subject: [PATCH 08/19] style: rustfmt v3_json_storage_tests --- tests/sqlx/tests/v3_json_storage_tests.rs | 30 ++++++++++++++++++----- 1 file changed, 24 insertions(+), 6 deletions(-) diff --git a/tests/sqlx/tests/v3_json_storage_tests.rs b/tests/sqlx/tests/v3_json_storage_tests.rs index 91992e79d..e589bd86c 100644 --- a/tests/sqlx/tests/v3_json_storage_tests.rs +++ b/tests/sqlx/tests/v3_json_storage_tests.rs @@ -93,9 +93,19 @@ async fn storage_fixture_shape(pool: PgPool) -> anyhow::Result<()> { .await?; let obj = payload.as_object().expect("payload is an object"); - assert_eq!(obj.get("v"), Some(&serde_json::json!(3)), "envelope version"); - assert!(obj.contains_key("i"), "storage payload carries index metadata"); - assert!(obj.contains_key("c"), "storage payload carries a ciphertext"); + assert_eq!( + obj.get("v"), + Some(&serde_json::json!(3)), + "envelope version" + ); + assert!( + obj.contains_key("i"), + "storage payload carries index metadata" + ); + assert!( + obj.contains_key("c"), + "storage payload carries a ciphertext" + ); // Storage-only: no SteVec array / form discriminator, and — crucially — no // index-term keys, because nothing is searchable. for absent in ["sv", "k", "hm", "ob", "bf", "op"] { @@ -216,7 +226,9 @@ async fn storage_path_operators_unknown_literal_fall_through(pool: PgPool) -> an ) .fetch_one(&pool) .await - .map_err(|e| anyhow::anyhow!("`payload -> 'c'` unexpectedly raised (resolution changed?): {e}"))?; + .map_err(|e| { + anyhow::anyhow!("`payload -> 'c'` unexpectedly raised (resolution changed?): {e}") + })?; anyhow::ensure!( matches!(c_val, Some(serde_json::Value::String(_))), "`payload -> 'c'` should echo the ciphertext string, got {c_val:?}" @@ -227,7 +239,10 @@ async fn storage_path_operators_unknown_literal_fall_through(pool: PgPool) -> an ) .fetch_one(&pool) .await?; - anyhow::ensure!(missing.is_none(), "`payload -> 'missing'` should be NULL, got {missing:?}"); + anyhow::ensure!( + missing.is_none(), + "`payload -> 'missing'` should be NULL, got {missing:?}" + ); // `?` (unknown literal) tests envelope-key presence and returns native bool. let has_c: bool = sqlx::query_scalar( @@ -235,7 +250,10 @@ async fn storage_path_operators_unknown_literal_fall_through(pool: PgPool) -> an ) .fetch_one(&pool) .await?; - anyhow::ensure!(has_c, "`payload ? 'c'` should be true (envelope has a `c` key)"); + anyhow::ensure!( + has_c, + "`payload ? 'c'` should be true (envelope has a `c` key)" + ); let has_absent: bool = sqlx::query_scalar( "SELECT payload ? 'absent' FROM fixtures.v3_json_storage ORDER BY id LIMIT 1", From 3d342d7bb38b4ffd68d094690effc7d2e1598fa9 Mon Sep 17 00:00:00 2001 From: Toby Hede Date: Wed, 15 Jul 2026 18:30:56 +1000 Subject: [PATCH 09/19] chore(changeset): json storage/rename is a patch (3.0.1) --- .changeset/json-storage-and-search-rename.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.changeset/json-storage-and-search-rename.md b/.changeset/json-storage-and-search-rename.md index b9f3b7f91..8ab8c01af 100644 --- a/.changeset/json-storage-and-search-rename.md +++ b/.changeset/json-storage-and-search-rename.md @@ -1,5 +1,5 @@ --- -'@cipherstash/eql': minor +'@cipherstash/eql': patch --- **The encrypted-JSON domains are renamed for a consistent `public.eql_v3_json` family, and a new ciphertext-only storage domain is added.** The bare name `public.eql_v3_json` is now a **storage-only** domain (a single opaque ciphertext, `{v,i,c}` envelope, no index terms — the JSON analogue of `public.eql_v3_boolean`, for encrypt-at-rest with no server-side searchability). The searchable SteVec document that previously held the bare `public.eql_v3_json` name is renamed to `public.eql_v3_json_search`; its supporting domains follow: `public.eql_v3_jsonb_entry` → `public.eql_v3_json_entry`, and the containment needle `eql_v3.query_jsonb` → `eql_v3.query_json`. This makes the JSON family follow the same convention as every scalar family — the bare family name is the storage-only domain and a suffix (`_search`, mirroring text's `_search`) marks the searchable variant. Reach for `public.eql_v3_json_search` when you need containment/field queries over encrypted JSON (`@>`, path access) and `public.eql_v3_json` when you only need to store and round-trip an encrypted JSON value. Callers on the previous names must update column declarations and query casts (`WHERE doc @> $1::eql_v3.query_json`); the bindings, `DomainPayload`/`QueryPayload` parse names, and published JSON Schema file names all move to the new names. From d4ff8c6ee43426a6a5220ffcd26890ca9798fdca Mon Sep 17 00:00:00 2001 From: Toby Hede Date: Thu, 16 Jul 2026 12:16:42 +1000 Subject: [PATCH 10/19] chore(release): open eql-3.0.1 release batching branch From 18d58e79741c1503e8d58acfa525eb4ceeb540c9 Mon Sep 17 00:00:00 2001 From: Toby Hede Date: Wed, 15 Jul 2026 18:15:37 +1000 Subject: [PATCH 11/19] feat(eql_v3)!: rename text bloom fuzzy match to `@@` / `eql_v3.matches` MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The bloom fuzzy match on the text match/search domains (`public.eql_v3_text_match` / `text_search` / `text_search_ore`) was spelled with the containment operators `@>` / `<@`, backed by `eql_v3.contains` / `eql_v3.contained_by`. That promised containment semantics it does not provide: it is array containment over two bloom filters (downcased 3-gram token sets) — a probabilistic, order-insensitive, one-sided match. It is now a single directional operator `@@` backed by `eql_v3.matches`; the reverse `contained_by` direction is dropped, and `@>` / `<@` now RAISE on these domains. Genuine JSON containment (`public.eql_v3_json_search` `@>`/`<@`, `ste_vec_contains`) is untouched. Generator (the surface is generated from the catalog, not hand-written): - `Term::Bloom` advertises `@@` (was `@>`/`<@`), routing to `match_term`. - `@@` gains a per-signature `blocker_only` flag: the three symmetric domain/jsonb overloads are the supported match; the `(domain, jsonpath)` overload stays a blocker on every domain (the "no silent native jsonb ops" guarantee). - `Operator::wrapper_function_name()` maps supported `@@` -> `eql_v3.matches` while the blocker keeps `eql_v3_internal."@@"`; `Operator::body_operator()` keeps the wrapper body as `match_term(a) @> match_term(b)`, so `col @@ $1` inlines to the same GIN-indexable array-containment (no new SEM operator). Regenerated in place: `src/v3/scalars/*`, Rust/TS/JSON bindings, and the bundled SQL installers (crate + npm) so packaged installs match the advertised API. `@@` symmetric overloads render as blockers on non-Bloom domains, consistent with how `@>`/`<@` already do. Tests/docs: rewrote the text match/smoke suites, property + matrix match arms, operator-equivalents list, splinter allowlist; regenerated the public-surface, matrix-name, and cargo-expand snapshots; added the U-008 upgrade note and a `major` changeset; corrected rollback guidance, "bloom fuzzy match" wording, `text_search_ore` coverage in the reference matrices, and the BloomFilter / unsupported-blocker doc surface. Client code emitting `eql_v3.contains(` for text match must switch to `eql_v3.matches(` in lockstep. BREAKING CHANGE: `@>` / `<@` and `eql_v3.contains` / `eql_v3.contained_by` on the text match/search domains now raise. Migrate to `@@` / `eql_v3.matches`. --- .changeset/rename-text-match-operator.md | 5 + SUPABASE.md | 23 +- .../eql-bindings/bindings/v3/BloomFilter.ts | 5 +- crates/eql-bindings/bindings/v3/TextMatch.ts | 2 +- .../bindings/v3/TextMatchQuery.ts | 2 +- crates/eql-bindings/bindings/v3/TextSearch.ts | 2 +- .../eql-bindings/bindings/v3/TextSearchOre.ts | 2 +- .../bindings/v3/TextSearchOreQuery.ts | 2 +- .../bindings/v3/TextSearchQuery.ts | 2 +- .../schema/v3/eql_v3_text_match.json | 4 +- .../schema/v3/eql_v3_text_search.json | 4 +- .../schema/v3/eql_v3_text_search_ore.json | 4 +- .../schema/v3/query_text_match.json | 4 +- .../schema/v3/query_text_search.json | 4 +- .../schema/v3/query_text_search_ore.json | 4 +- .../eql-bindings/sql/cipherstash-encrypt.sql | 55028 ++++++++-------- crates/eql-bindings/sql/release-manifest.json | 2 +- crates/eql-bindings/src/v3/terms.rs | 11 +- crates/eql-bindings/src/v3/text.rs | 12 +- crates/eql-codegen/src/bindings.rs | 2 +- crates/eql-codegen/src/context.rs | 38 +- crates/eql-codegen/src/generate.rs | 83 +- crates/eql-codegen/src/operator_surface.rs | 122 +- .../templates/functions/unsupported.sql.j2 | 11 +- crates/eql-domains/src/term.rs | 2 +- crates/eql-domains/src/tests.rs | 16 +- .../adding-a-scalar-encrypted-domain-type.md | 74 +- docs/reference/catalog-driven-architecture.md | 2 +- docs/reference/database-indexes.md | 6 +- docs/reference/eql-functions.md | 16 +- docs/reference/permissions.md | 2 +- docs/reference/sql-support.md | 42 +- docs/upgrading/v3.0.md | 82 +- packages/eql/sql/cipherstash-encrypt.sql | 55028 ++++++++-------- packages/eql/sql/release-manifest.json | 2 +- .../eql/src/generated/release-manifest.ts | 2 +- .../schema/v3/eql_v3_text_match.json | 4 +- .../schema/v3/eql_v3_text_search.json | 4 +- .../schema/v3/eql_v3_text_search_ore.json | 4 +- .../generated/schema/v3/query_text_match.json | 4 +- .../schema/v3/query_text_search.json | 4 +- .../schema/v3/query_text_search_ore.json | 4 +- packages/eql/src/generated/v3/BloomFilter.ts | 5 +- packages/eql/src/generated/v3/TextMatch.ts | 2 +- .../eql/src/generated/v3/TextMatchQuery.ts | 2 +- packages/eql/src/generated/v3/TextSearch.ts | 2 +- .../eql/src/generated/v3/TextSearchOre.ts | 2 +- .../src/generated/v3/TextSearchOreQuery.ts | 2 +- .../eql/src/generated/v3/TextSearchQuery.ts | 2 +- src/v3/scalars/bigint/bigint_eq_functions.sql | 460 +- src/v3/scalars/bigint/bigint_eq_operators.sql | 15 + src/v3/scalars/bigint/bigint_functions.sql | 526 +- src/v3/scalars/bigint/bigint_operators.sql | 15 + .../scalars/bigint/bigint_ord_functions.sql | 328 +- .../bigint/bigint_ord_ope_functions.sql | 328 +- .../bigint/bigint_ord_ope_operators.sql | 15 + .../scalars/bigint/bigint_ord_operators.sql | 15 + .../bigint/bigint_ord_ore_functions.sql | 328 +- .../bigint/bigint_ord_ore_operators.sql | 15 + src/v3/scalars/boolean/boolean_functions.sql | 526 +- src/v3/scalars/boolean/boolean_operators.sql | 15 + src/v3/scalars/date/date_eq_functions.sql | 460 +- src/v3/scalars/date/date_eq_operators.sql | 15 + src/v3/scalars/date/date_functions.sql | 526 +- src/v3/scalars/date/date_operators.sql | 15 + src/v3/scalars/date/date_ord_functions.sql | 328 +- .../scalars/date/date_ord_ope_functions.sql | 328 +- .../scalars/date/date_ord_ope_operators.sql | 15 + src/v3/scalars/date/date_ord_operators.sql | 15 + .../scalars/date/date_ord_ore_functions.sql | 328 +- .../scalars/date/date_ord_ore_operators.sql | 15 + src/v3/scalars/double/double_eq_functions.sql | 460 +- src/v3/scalars/double/double_eq_operators.sql | 15 + src/v3/scalars/double/double_functions.sql | 526 +- src/v3/scalars/double/double_operators.sql | 15 + .../scalars/double/double_ord_functions.sql | 328 +- .../double/double_ord_ope_functions.sql | 328 +- .../double/double_ord_ope_operators.sql | 15 + .../scalars/double/double_ord_operators.sql | 15 + .../double/double_ord_ore_functions.sql | 328 +- .../double/double_ord_ore_operators.sql | 15 + .../scalars/integer/integer_eq_functions.sql | 460 +- .../scalars/integer/integer_eq_operators.sql | 15 + src/v3/scalars/integer/integer_functions.sql | 526 +- src/v3/scalars/integer/integer_operators.sql | 15 + .../scalars/integer/integer_ord_functions.sql | 328 +- .../integer/integer_ord_ope_functions.sql | 328 +- .../integer/integer_ord_ope_operators.sql | 15 + .../scalars/integer/integer_ord_operators.sql | 15 + .../integer/integer_ord_ore_functions.sql | 328 +- .../integer/integer_ord_ore_operators.sql | 15 + src/v3/scalars/json/json_functions.sql | 526 +- src/v3/scalars/json/json_operators.sql | 15 + .../scalars/numeric/numeric_eq_functions.sql | 460 +- .../scalars/numeric/numeric_eq_operators.sql | 15 + src/v3/scalars/numeric/numeric_functions.sql | 526 +- src/v3/scalars/numeric/numeric_operators.sql | 15 + .../scalars/numeric/numeric_ord_functions.sql | 328 +- .../numeric/numeric_ord_ope_functions.sql | 328 +- .../numeric/numeric_ord_ope_operators.sql | 15 + .../scalars/numeric/numeric_ord_operators.sql | 15 + .../numeric/numeric_ord_ore_functions.sql | 328 +- .../numeric/numeric_ord_ore_operators.sql | 15 + src/v3/scalars/real/real_eq_functions.sql | 460 +- src/v3/scalars/real/real_eq_operators.sql | 15 + src/v3/scalars/real/real_functions.sql | 526 +- src/v3/scalars/real/real_operators.sql | 15 + src/v3/scalars/real/real_ord_functions.sql | 328 +- .../scalars/real/real_ord_ope_functions.sql | 328 +- .../scalars/real/real_ord_ope_operators.sql | 15 + src/v3/scalars/real/real_ord_operators.sql | 15 + .../scalars/real/real_ord_ore_functions.sql | 328 +- .../scalars/real/real_ord_ore_operators.sql | 15 + .../smallint/smallint_eq_functions.sql | 460 +- .../smallint/smallint_eq_operators.sql | 15 + .../scalars/smallint/smallint_functions.sql | 526 +- .../scalars/smallint/smallint_operators.sql | 15 + .../smallint/smallint_ord_functions.sql | 328 +- .../smallint/smallint_ord_ope_functions.sql | 328 +- .../smallint/smallint_ord_ope_operators.sql | 15 + .../smallint/smallint_ord_operators.sql | 15 + .../smallint/smallint_ord_ore_functions.sql | 328 +- .../smallint/smallint_ord_ore_operators.sql | 15 + .../text/query_text_match_functions.sql | 20 +- .../text/query_text_match_operators.sql | 24 +- .../text/query_text_search_functions.sql | 20 +- .../text/query_text_search_operators.sql | 24 +- .../text/query_text_search_ore_functions.sql | 20 +- .../text/query_text_search_ore_operators.sql | 24 +- src/v3/scalars/text/query_text_types.sql | 6 +- src/v3/scalars/text/text_eq_functions.sql | 460 +- src/v3/scalars/text/text_eq_operators.sql | 15 + src/v3/scalars/text/text_functions.sql | 526 +- src/v3/scalars/text/text_match_functions.sql | 560 +- src/v3/scalars/text/text_match_operators.sql | 48 +- src/v3/scalars/text/text_operators.sql | 15 + src/v3/scalars/text/text_ord_functions.sql | 328 +- .../scalars/text/text_ord_ope_functions.sql | 328 +- .../scalars/text/text_ord_ope_operators.sql | 15 + src/v3/scalars/text/text_ord_operators.sql | 15 + .../scalars/text/text_ord_ore_functions.sql | 328 +- .../scalars/text/text_ord_ore_operators.sql | 15 + src/v3/scalars/text/text_search_functions.sql | 362 +- src/v3/scalars/text/text_search_operators.sql | 48 +- .../text/text_search_ore_functions.sql | 362 +- .../text/text_search_ore_operators.sql | 48 +- src/v3/scalars/text/text_types.sql | 6 +- .../timestamp/timestamp_eq_functions.sql | 460 +- .../timestamp/timestamp_eq_operators.sql | 15 + .../scalars/timestamp/timestamp_functions.sql | 526 +- .../scalars/timestamp/timestamp_operators.sql | 15 + .../timestamp/timestamp_ord_functions.sql | 328 +- .../timestamp/timestamp_ord_ope_functions.sql | 328 +- .../timestamp/timestamp_ord_ope_operators.sql | 15 + .../timestamp/timestamp_ord_operators.sql | 15 + .../timestamp/timestamp_ord_ore_functions.sql | 328 +- .../timestamp/timestamp_ord_ore_operators.sql | 15 + src/v3/sem/bloom_filter/types.sql | 15 +- tasks/test/splinter.sh | 5 +- .../sqlx/snapshots/eql_v3_public_surface.txt | 45 +- tests/sqlx/snapshots/matrix_tests_text.txt | 8 +- tests/sqlx/snapshots/text_expanded.rs | 108 +- tests/sqlx/src/matrix.rs | 22 +- tests/sqlx/src/property.rs | 60 +- tests/sqlx/src/scalar_domains.rs | 14 +- .../encrypted_domain/property/match_smoke.rs | 8 +- .../tests/encrypted_domain/text/text_match.rs | 233 +- .../tests/encrypted_domain/text/text_smoke.rs | 135 +- .../tests/v3_operator_equivalents_tests.rs | 6 +- 169 files changed, 74350 insertions(+), 58061 deletions(-) create mode 100644 .changeset/rename-text-match-operator.md diff --git a/.changeset/rename-text-match-operator.md b/.changeset/rename-text-match-operator.md new file mode 100644 index 000000000..3da0d87eb --- /dev/null +++ b/.changeset/rename-text-match-operator.md @@ -0,0 +1,5 @@ +--- +'@cipherstash/eql': patch +--- + +**Text bloom fuzzy match is renamed to `@@` / `eql_v3.matches` — it is n-gram token matching, not containment.** On the text match/search domains (`public.eql_v3_text_match`, `public.eql_v3_text_search`, `public.eql_v3_text_search_ore`) the fuzzy match was previously spelled with the containment operators `@>` / `<@`, backed by `eql_v3.contains` / `eql_v3.contained_by`. That promised substring/containment semantics the operation does not provide: it is array containment over two bloom filters built from the downcased 3-gram token set — a probabilistic, order- and multiplicity-insensitive, one-sided match (a `true` may be a false positive; a `false` never is). The match is now a single directional operator `@@` backed by `eql_v3.matches` (`WHERE col @@ $1::public.eql_v3_text_match`), and the reverse `contained_by` direction is dropped. `@>` and `<@` now **raise** "operator not supported" on the text match domains. The functional GIN index recipe is unchanged (`GIN (eql_v3.match_term(col))`): `col @@ $1` inlines through `match_term` to the same array-containment the index supports. Genuine JSON containment (`public.eql_v3_json_search` `@>`/`<@`, `eql_v3.ste_vec_contains`) keeps the containment vocabulary and is unaffected. This is the SQL-layer counterpart of the SDK's `contains()` → `matches()` rename; callers or SDKs emitting `eql_v3.contains(col, …)` / `col @> $1` for text match must switch to `eql_v3.matches(col, …)` / `col @@ $1` in lockstep. See upgrade note U-008. diff --git a/SUPABASE.md b/SUPABASE.md index 0a758c7b0..f35f110e6 100644 --- a/SUPABASE.md +++ b/SUPABASE.md @@ -63,7 +63,7 @@ or [CipherStash Stack](https://github.com/cipherstash/stack): - `public._eq` carries an `hm` term — supports `=` / `<>`, `GROUP BY`, `DISTINCT`. - `public._ord` (and the `_ord_ope` twin) carries an `op` term — adds `<` `<=` `>` `>=`, `ORDER BY`, `MIN` / `MAX`. `public._ord_ore` is the block-ORE (`ob`) equivalent. -- `public.eql_v3_text_match` carries a `bf` term — supports bloom-filter token containment (`@>` / `<@`). +- `public.eql_v3_text_match` carries a `bf` term — supports bloom-filter token match (`@@` / `eql_v3.matches`; `@>` / `<@` raise). - `public.eql_v3_text_search` carries all three terms — equality, ordering, and containment on `text`. `public.eql_v3_text_search_ore` is its block-ORE equivalent. Configuring those columns is a client-side concern. See: @@ -88,11 +88,10 @@ is awkward to express. | `<=` | `eql_v3.lte(col, $1)` | `SELECT * FROM events WHERE eql_v3.lte(encrypted_at, $1)` | | `>` | `eql_v3.gt(col, $1)` | `SELECT * FROM events WHERE eql_v3.gt(encrypted_at, $1)` | | `>=` | `eql_v3.gte(col, $1)` | `SELECT * FROM events WHERE eql_v3.gte(encrypted_at, $1)` | -| `@>` | `eql_v3.contains(col, $1)` | `SELECT * FROM users WHERE eql_v3.contains(encrypted_name, $1)` | -| `<@` | `eql_v3.contained_by(col, $1)` | `SELECT * FROM users WHERE eql_v3.contained_by(encrypted_name, $1)` | +| `@@` | `eql_v3.matches(col, $1)` | `SELECT * FROM users WHERE eql_v3.matches(encrypted_name, $1)` | -`eql_v3.eq` / `neq` / `lt` / `lte` / `gt` / `gte` / `contains` / -`contained_by` are each overloaded for `(domain, domain)`, `(domain, jsonb)`, +`eql_v3.eq` / `neq` / `lt` / `lte` / `gt` / `gte` / `matches` +are each overloaded for `(domain, domain)`, `(domain, jsonb)`, and `(jsonb, domain)`, so a `jsonb` operand is accepted directly and resolved against the typed side. @@ -162,16 +161,18 @@ There is **no SQL `LIKE` / `ILIKE` pattern matching on encrypted text in `eql_v3`**. The `LIKE` / `ILIKE` operators (`~~` / `~~*`) are blocked on every encrypted domain variant and raise an "operator not supported" exception. -Text search is now **bloom-filter token containment** via `@>` / `<@` on a -column typed `public.eql_v3_text_match` or `public.eql_v3_text_search`. This tests whether -the encrypted text contains the (encrypted) search terms — a probabilistic -ngram match, not a SQL pattern match: +Text search is now **bloom-filter token matching** via the `@@` operator +(`eql_v3.matches`) on a column typed `public.eql_v3_text_match` or +`public.eql_v3_text_search`. This tests whether the encrypted text matches the +(encrypted) search terms — a probabilistic ngram match, not a SQL pattern match +and not containment (the `@>` / `<@` containment operators raise on these +domains): ```sql -- Column typed public.eql_v3_text_match or public.eql_v3_text_search, -- with: CREATE INDEX ... USING gin (eql_v3.match_term(encrypted_name)); -SELECT * FROM users WHERE encrypted_name @> $1; -SELECT * FROM users WHERE eql_v3.contains(encrypted_name, $1); +SELECT * FROM users WHERE encrypted_name @@ $1; +SELECT * FROM users WHERE eql_v3.matches(encrypted_name, $1); ``` Case sensitivity and tokenisation are properties of how the value was diff --git a/crates/eql-bindings/bindings/v3/BloomFilter.ts b/crates/eql-bindings/bindings/v3/BloomFilter.ts index 6861ce1c5..a64241cf5 100644 --- a/crates/eql-bindings/bindings/v3/BloomFilter.ts +++ b/crates/eql-bindings/bindings/v3/BloomFilter.ts @@ -1,8 +1,9 @@ // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually. /** - * Bloom-filter match term — the `bf` wire key. Backs the `_match` domains - * (`@>`/`<@` containment). + * Bloom-filter match term — the `bf` wire key. Backs the fuzzy-match `@@` + * (`eql_v3.matches`) surface on the `_match` domains; the containment operators + * `@>`/`<@` survive only as internal blockers that raise (CIP-3517). * * **Signed** i16, not u16: EQL stores the filter as PostgreSQL `smallint[]`, * and filters sized above 32768 emit upper-half bit positions as negative diff --git a/crates/eql-bindings/bindings/v3/TextMatch.ts b/crates/eql-bindings/bindings/v3/TextMatch.ts index eef14fe15..b47956a03 100644 --- a/crates/eql-bindings/bindings/v3/TextMatch.ts +++ b/crates/eql-bindings/bindings/v3/TextMatch.ts @@ -7,6 +7,6 @@ import type { SchemaVersion } from "./SchemaVersion"; /** * `public.eql_v3_text_match` — match domain. * - * Operators: `@>` `<@`. Required keys: `v` `i` `c` `bf`. + * Operators: `@@`. Required keys: `v` `i` `c` `bf`. */ export type TextMatch = { v: SchemaVersion, i: Identifier, c: Ciphertext, bf: BloomFilter, }; diff --git a/crates/eql-bindings/bindings/v3/TextMatchQuery.ts b/crates/eql-bindings/bindings/v3/TextMatchQuery.ts index 4e525ab6c..ce5a38700 100644 --- a/crates/eql-bindings/bindings/v3/TextMatchQuery.ts +++ b/crates/eql-bindings/bindings/v3/TextMatchQuery.ts @@ -6,6 +6,6 @@ import type { SchemaVersion } from "./SchemaVersion"; /** * `eql_v3.query_text_match` — match domain query operand. * - * Operators: `@>` `<@`. Required keys: `v` `i` `bf`. + * Operators: `@@`. Required keys: `v` `i` `bf`. */ export type TextMatchQuery = { v: SchemaVersion, i: Identifier, bf: BloomFilter, }; diff --git a/crates/eql-bindings/bindings/v3/TextSearch.ts b/crates/eql-bindings/bindings/v3/TextSearch.ts index 02a81011f..771315115 100644 --- a/crates/eql-bindings/bindings/v3/TextSearch.ts +++ b/crates/eql-bindings/bindings/v3/TextSearch.ts @@ -9,6 +9,6 @@ import type { SchemaVersion } from "./SchemaVersion"; /** * `public.eql_v3_text_search` — search domain. * - * Operators: `=` `<>` `<` `<=` `>` `>=` `@>` `<@`. Required keys: `v` `i` `c` `hm` `op` `bf`. + * Operators: `=` `<>` `<` `<=` `>` `>=` `@@`. Required keys: `v` `i` `c` `hm` `op` `bf`. */ export type TextSearch = { v: SchemaVersion, i: Identifier, c: Ciphertext, hm: Hmac256, op: OpeCllw, bf: BloomFilter, }; diff --git a/crates/eql-bindings/bindings/v3/TextSearchOre.ts b/crates/eql-bindings/bindings/v3/TextSearchOre.ts index 82a910cf4..47761ee95 100644 --- a/crates/eql-bindings/bindings/v3/TextSearchOre.ts +++ b/crates/eql-bindings/bindings/v3/TextSearchOre.ts @@ -9,6 +9,6 @@ import type { SchemaVersion } from "./SchemaVersion"; /** * `public.eql_v3_text_search_ore` — search domain. * - * Operators: `=` `<>` `<` `<=` `>` `>=` `@>` `<@`. Required keys: `v` `i` `c` `hm` `ob` `bf`. + * Operators: `=` `<>` `<` `<=` `>` `>=` `@@`. Required keys: `v` `i` `c` `hm` `ob` `bf`. */ export type TextSearchOre = { v: SchemaVersion, i: Identifier, c: Ciphertext, hm: Hmac256, ob: OreBlock256, bf: BloomFilter, }; diff --git a/crates/eql-bindings/bindings/v3/TextSearchOreQuery.ts b/crates/eql-bindings/bindings/v3/TextSearchOreQuery.ts index 8e7bd1066..3b3069a30 100644 --- a/crates/eql-bindings/bindings/v3/TextSearchOreQuery.ts +++ b/crates/eql-bindings/bindings/v3/TextSearchOreQuery.ts @@ -8,6 +8,6 @@ import type { SchemaVersion } from "./SchemaVersion"; /** * `eql_v3.query_text_search_ore` — search domain query operand. * - * Operators: `=` `<>` `<` `<=` `>` `>=` `@>` `<@`. Required keys: `v` `i` `hm` `ob` `bf`. + * Operators: `=` `<>` `<` `<=` `>` `>=` `@@`. Required keys: `v` `i` `hm` `ob` `bf`. */ export type TextSearchOreQuery = { v: SchemaVersion, i: Identifier, hm: Hmac256, ob: OreBlock256, bf: BloomFilter, }; diff --git a/crates/eql-bindings/bindings/v3/TextSearchQuery.ts b/crates/eql-bindings/bindings/v3/TextSearchQuery.ts index 7f29899eb..c2e5207ad 100644 --- a/crates/eql-bindings/bindings/v3/TextSearchQuery.ts +++ b/crates/eql-bindings/bindings/v3/TextSearchQuery.ts @@ -8,6 +8,6 @@ import type { SchemaVersion } from "./SchemaVersion"; /** * `eql_v3.query_text_search` — search domain query operand. * - * Operators: `=` `<>` `<` `<=` `>` `>=` `@>` `<@`. Required keys: `v` `i` `hm` `op` `bf`. + * Operators: `=` `<>` `<` `<=` `>` `>=` `@@`. Required keys: `v` `i` `hm` `op` `bf`. */ export type TextSearchQuery = { v: SchemaVersion, i: Identifier, hm: Hmac256, op: OpeCllw, bf: BloomFilter, }; diff --git a/crates/eql-bindings/schema/v3/eql_v3_text_match.json b/crates/eql-bindings/schema/v3/eql_v3_text_match.json index e3b30c709..ab09f364d 100644 --- a/crates/eql-bindings/schema/v3/eql_v3_text_match.json +++ b/crates/eql-bindings/schema/v3/eql_v3_text_match.json @@ -1,7 +1,7 @@ { "$defs": { "BloomFilter": { - "description": "Bloom-filter match term — the `bf` wire key. Backs the `_match` domains (`@>`/`<@` containment). Signed i16: EQL stores the filter as PostgreSQL `smallint[]`, and filters sized above 32768 emit upper-half bit positions as negative signed values.", + "description": "Bloom-filter match term — the `bf` wire key. Backs the fuzzy-match `@@` (`eql_v3.matches`) surface on the `_match` domains; the containment operators `@>`/`<@` survive only as internal blockers that raise (CIP-3517). Signed i16: EQL stores the filter as PostgreSQL `smallint[]`, and filters sized above 32768 emit upper-half bit positions as negative signed values.", "items": { "format": "int16", "maximum": 32767, @@ -42,7 +42,7 @@ "$id": "https://schemas.cipherstash.com/eql/v3/eql_v3_text_match.json", "$schema": "https://json-schema.org/draft/2020-12/schema", "additionalProperties": false, - "description": "`public.eql_v3_text_match` — match domain.\n\nOperators: `@>` `<@`. Required keys: `v` `i` `c` `bf`.", + "description": "`public.eql_v3_text_match` — match domain.\n\nOperators: `@@`. Required keys: `v` `i` `c` `bf`.", "properties": { "bf": { "$ref": "#/$defs/BloomFilter" diff --git a/crates/eql-bindings/schema/v3/eql_v3_text_search.json b/crates/eql-bindings/schema/v3/eql_v3_text_search.json index f4982fa46..759cc54af 100644 --- a/crates/eql-bindings/schema/v3/eql_v3_text_search.json +++ b/crates/eql-bindings/schema/v3/eql_v3_text_search.json @@ -1,7 +1,7 @@ { "$defs": { "BloomFilter": { - "description": "Bloom-filter match term — the `bf` wire key. Backs the `_match` domains (`@>`/`<@` containment). Signed i16: EQL stores the filter as PostgreSQL `smallint[]`, and filters sized above 32768 emit upper-half bit positions as negative signed values.", + "description": "Bloom-filter match term — the `bf` wire key. Backs the fuzzy-match `@@` (`eql_v3.matches`) surface on the `_match` domains; the containment operators `@>`/`<@` survive only as internal blockers that raise (CIP-3517). Signed i16: EQL stores the filter as PostgreSQL `smallint[]`, and filters sized above 32768 emit upper-half bit positions as negative signed values.", "items": { "format": "int16", "maximum": 32767, @@ -50,7 +50,7 @@ "$id": "https://schemas.cipherstash.com/eql/v3/eql_v3_text_search.json", "$schema": "https://json-schema.org/draft/2020-12/schema", "additionalProperties": false, - "description": "`public.eql_v3_text_search` — search domain.\n\nOperators: `=` `<>` `<` `<=` `>` `>=` `@>` `<@`. Required keys: `v` `i` `c` `hm` `op` `bf`.", + "description": "`public.eql_v3_text_search` — search domain.\n\nOperators: `=` `<>` `<` `<=` `>` `>=` `@@`. Required keys: `v` `i` `c` `hm` `op` `bf`.", "properties": { "bf": { "$ref": "#/$defs/BloomFilter" diff --git a/crates/eql-bindings/schema/v3/eql_v3_text_search_ore.json b/crates/eql-bindings/schema/v3/eql_v3_text_search_ore.json index c286e443e..d7fc56da6 100644 --- a/crates/eql-bindings/schema/v3/eql_v3_text_search_ore.json +++ b/crates/eql-bindings/schema/v3/eql_v3_text_search_ore.json @@ -1,7 +1,7 @@ { "$defs": { "BloomFilter": { - "description": "Bloom-filter match term — the `bf` wire key. Backs the `_match` domains (`@>`/`<@` containment). Signed i16: EQL stores the filter as PostgreSQL `smallint[]`, and filters sized above 32768 emit upper-half bit positions as negative signed values.", + "description": "Bloom-filter match term — the `bf` wire key. Backs the fuzzy-match `@@` (`eql_v3.matches`) surface on the `_match` domains; the containment operators `@>`/`<@` survive only as internal blockers that raise (CIP-3517). Signed i16: EQL stores the filter as PostgreSQL `smallint[]`, and filters sized above 32768 emit upper-half bit positions as negative signed values.", "items": { "format": "int16", "maximum": 32767, @@ -53,7 +53,7 @@ "$id": "https://schemas.cipherstash.com/eql/v3/eql_v3_text_search_ore.json", "$schema": "https://json-schema.org/draft/2020-12/schema", "additionalProperties": false, - "description": "`public.eql_v3_text_search_ore` — search domain.\n\nOperators: `=` `<>` `<` `<=` `>` `>=` `@>` `<@`. Required keys: `v` `i` `c` `hm` `ob` `bf`.", + "description": "`public.eql_v3_text_search_ore` — search domain.\n\nOperators: `=` `<>` `<` `<=` `>` `>=` `@@`. Required keys: `v` `i` `c` `hm` `ob` `bf`.", "properties": { "bf": { "$ref": "#/$defs/BloomFilter" diff --git a/crates/eql-bindings/schema/v3/query_text_match.json b/crates/eql-bindings/schema/v3/query_text_match.json index d7a781677..aa9f5a984 100644 --- a/crates/eql-bindings/schema/v3/query_text_match.json +++ b/crates/eql-bindings/schema/v3/query_text_match.json @@ -1,7 +1,7 @@ { "$defs": { "BloomFilter": { - "description": "Bloom-filter match term — the `bf` wire key. Backs the `_match` domains (`@>`/`<@` containment). Signed i16: EQL stores the filter as PostgreSQL `smallint[]`, and filters sized above 32768 emit upper-half bit positions as negative signed values.", + "description": "Bloom-filter match term — the `bf` wire key. Backs the fuzzy-match `@@` (`eql_v3.matches`) surface on the `_match` domains; the containment operators `@>`/`<@` survive only as internal blockers that raise (CIP-3517). Signed i16: EQL stores the filter as PostgreSQL `smallint[]`, and filters sized above 32768 emit upper-half bit positions as negative signed values.", "items": { "format": "int16", "maximum": 32767, @@ -38,7 +38,7 @@ "$id": "https://schemas.cipherstash.com/eql/v3/query_text_match.json", "$schema": "https://json-schema.org/draft/2020-12/schema", "additionalProperties": false, - "description": "`eql_v3.query_text_match` — match domain query operand.\n\nOperators: `@>` `<@`. Required keys: `v` `i` `bf`.", + "description": "`eql_v3.query_text_match` — match domain query operand.\n\nOperators: `@@`. Required keys: `v` `i` `bf`.", "properties": { "bf": { "$ref": "#/$defs/BloomFilter" diff --git a/crates/eql-bindings/schema/v3/query_text_search.json b/crates/eql-bindings/schema/v3/query_text_search.json index d2d9eff7b..6d955fa63 100644 --- a/crates/eql-bindings/schema/v3/query_text_search.json +++ b/crates/eql-bindings/schema/v3/query_text_search.json @@ -1,7 +1,7 @@ { "$defs": { "BloomFilter": { - "description": "Bloom-filter match term — the `bf` wire key. Backs the `_match` domains (`@>`/`<@` containment). Signed i16: EQL stores the filter as PostgreSQL `smallint[]`, and filters sized above 32768 emit upper-half bit positions as negative signed values.", + "description": "Bloom-filter match term — the `bf` wire key. Backs the fuzzy-match `@@` (`eql_v3.matches`) surface on the `_match` domains; the containment operators `@>`/`<@` survive only as internal blockers that raise (CIP-3517). Signed i16: EQL stores the filter as PostgreSQL `smallint[]`, and filters sized above 32768 emit upper-half bit positions as negative signed values.", "items": { "format": "int16", "maximum": 32767, @@ -46,7 +46,7 @@ "$id": "https://schemas.cipherstash.com/eql/v3/query_text_search.json", "$schema": "https://json-schema.org/draft/2020-12/schema", "additionalProperties": false, - "description": "`eql_v3.query_text_search` — search domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=` `@>` `<@`. Required keys: `v` `i` `hm` `op` `bf`.", + "description": "`eql_v3.query_text_search` — search domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=` `@@`. Required keys: `v` `i` `hm` `op` `bf`.", "properties": { "bf": { "$ref": "#/$defs/BloomFilter" diff --git a/crates/eql-bindings/schema/v3/query_text_search_ore.json b/crates/eql-bindings/schema/v3/query_text_search_ore.json index 1b3620062..01fca8aa9 100644 --- a/crates/eql-bindings/schema/v3/query_text_search_ore.json +++ b/crates/eql-bindings/schema/v3/query_text_search_ore.json @@ -1,7 +1,7 @@ { "$defs": { "BloomFilter": { - "description": "Bloom-filter match term — the `bf` wire key. Backs the `_match` domains (`@>`/`<@` containment). Signed i16: EQL stores the filter as PostgreSQL `smallint[]`, and filters sized above 32768 emit upper-half bit positions as negative signed values.", + "description": "Bloom-filter match term — the `bf` wire key. Backs the fuzzy-match `@@` (`eql_v3.matches`) surface on the `_match` domains; the containment operators `@>`/`<@` survive only as internal blockers that raise (CIP-3517). Signed i16: EQL stores the filter as PostgreSQL `smallint[]`, and filters sized above 32768 emit upper-half bit positions as negative signed values.", "items": { "format": "int16", "maximum": 32767, @@ -49,7 +49,7 @@ "$id": "https://schemas.cipherstash.com/eql/v3/query_text_search_ore.json", "$schema": "https://json-schema.org/draft/2020-12/schema", "additionalProperties": false, - "description": "`eql_v3.query_text_search_ore` — search domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=` `@>` `<@`. Required keys: `v` `i` `hm` `ob` `bf`.", + "description": "`eql_v3.query_text_search_ore` — search domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=` `@@`. Required keys: `v` `i` `hm` `ob` `bf`.", "properties": { "bf": { "$ref": "#/$defs/BloomFilter" diff --git a/crates/eql-bindings/sql/cipherstash-encrypt.sql b/crates/eql-bindings/sql/cipherstash-encrypt.sql index f3ecc01d6..286ae1050 100644 --- a/crates/eql-bindings/sql/cipherstash-encrypt.sql +++ b/crates/eql-bindings/sql/cipherstash-encrypt.sql @@ -77,6 +77,53 @@ AS $$ SELECT ARRAY['eql_v3', 'eql_v3_internal']::name[] $$; +--! @file v3/sem/ope_cllw/types.sql +--! @brief CLLW OPE index term type for scalar range queries (eql_v3 SEM) +--! +--! Domain type representing a CLLW (Copyless Logarithmic Width) +--! Order-Preserving Encryption term. The ciphertext is stored hex-encoded in +--! the `op` field of encrypted scalar payloads (the `_ord_ope` domains); the +--! domain carries the hex-decoded bytes. +--! +--! A DOMAIN over bytea, not a composite: the OPE ciphertext is +--! order-preserving under plain byte comparison, so the domain inherits +--! bytea's native comparison operators and DEFAULT btree operator class +--! outright — no hand-written operators, comparator, or operator class (the +--! same pattern as eql_v3_internal.hmac_256 over text). That keeps the whole +--! comparison chain inlinable, so a functional btree index on +--! `eql_v3.ord_term(col)` engages structurally for the `_ord` / `_ord_ope` +--! domains' comparison operators. Contrast eql_v3_internal.ore_cllw (`oc`), the SteVec +--! CLLW-*ORE* composite compared by a custom per-byte protocol. +--! +--! @note Transient type used only during query execution. +--! @see eql_v3_internal.ope_cllw +CREATE DOMAIN eql_v3_internal.ope_cllw AS bytea; + +--! @file v3/sem/ore_block_256/types.sql +--! @brief ORE block index-term types (eql_v3 SEM). +--! +--! Self-contained eql_v3 copies of the Order-Revealing Encryption block types +--! (design D1/D3). The eql_v2 originals are unchanged. + +--! @brief ORE block term type for Order-Revealing Encryption +--! +--! Composite type representing a single ORE block term. Stores encrypted data +--! as bytea that enables range comparisons without decryption. +CREATE TYPE eql_v3_internal.ore_block_256_term AS ( + bytes bytea +); + + +--! @brief ORE block index term type for range queries +--! +--! Composite type containing an array of ORE block terms. The array is stored +--! in the 'ob' field of encrypted data payloads. +--! +--! @note Transient type used only during query execution. +CREATE TYPE eql_v3_internal.ore_block_256 AS ( + terms eql_v3_internal.ore_block_256_term[] +); + --! @file v3/crypto.sql --! @brief PostgreSQL pgcrypto extension enablement (eql_v3 fork) --! @@ -185,30 +232,164 @@ $$ LANGUAGE plpgsql; COMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(jsonb) IS 'eql-inline-critical: per-encrypted-value ORE opclass-path helper; must stay unpinned (SET search_path adds per-call overhead)'; ---! @file v3/sem/ore_block_256/types.sql ---! @brief ORE block index-term types (eql_v3 SEM). +--! @file v3/sem/hmac_256/types.sql +--! @brief HMAC-SHA256 index term type (eql_v3 SEM) --! ---! Self-contained eql_v3 copies of the Order-Revealing Encryption block types ---! (design D1/D3). The eql_v2 originals are unchanged. +--! Domain type representing HMAC-SHA256 hash values. Used for exact-match +--! encrypted searches. The hash is stored in the 'hm' field of encrypted data +--! payloads. Self-contained eql_v3 copy (design D1/D3); the eql_v2 original is +--! unchanged. +--! +--! @note Transient type used only during query execution. +CREATE DOMAIN eql_v3_internal.hmac_256 AS text; ---! @brief ORE block term type for Order-Revealing Encryption +--! @file v3/sem/bloom_filter/types.sql +--! @brief Self-contained eql_v3 Bloom-filter SEM index-term type. + +--! @brief Bloom-filter index term: a bit array stored as smallint[]. --! ---! Composite type representing a single ORE block term. Stores encrypted data ---! as bytea that enables range comparisons without decryption. -CREATE TYPE eql_v3_internal.ore_block_256_term AS ( - bytes bytea -); +--! Backs the `matches` fuzzy-match capability (the public `@@` operator / +--! `eql_v3.matches`) on the text match/search domains. The filter is read from +--! the `bf` field of an encrypted jsonb payload. The match wrapper body reduces +--! to native `smallint[]` array-containment (`@>`) on this domain — inherited +--! through the base type — so a functional GIN index on `eql_v3.match_term(col)` +--! engages; this type itself needs no custom operators. +--! +--! @note The public operator is `@@` (fuzzy bloom-token matching), NOT the +--! containment operators `@>`/`<@`: the match is a probabilistic, one-sided +--! n-gram token match, not containment (CIP-3517). `@>`/`<@` on the text match +--! domains now raise. Internally the `@@` wrapper still reduces to the base +--! type's `@>` for GIN indexability. +--! @note Self-contained: references no eql_v2 symbol. +CREATE DOMAIN eql_v3_internal.bloom_filter AS smallint[]; +--! @file v3/scalars/functions.sql +--! @brief Shared blocker helper for the eql_v3 encrypted-domain families. +--! +--! Per-domain wrapper functions live in src/v3/scalars//. +--! Blockers in those files delegate to encrypted_domain_unsupported_bool +--! so every domain raises a uniform domain-specific error rather than +--! letting an unsupported operator fall through to native jsonb +--! behaviour. ---! @brief ORE block index term type for range queries +--! @brief Shared blocker helper. Raises 'operator X is not supported +--! for TYPE' so unsupported domain operators surface a clear +--! error rather than fall through to native jsonb behaviour. +--! @param type_name Domain type name (eql_v3.*) +--! @param operator_name Operator symbol (=, <, @>, ->, etc.) +--! @return boolean (never returns; always raises) +CREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_bool(type_name text, operator_name text) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name; +END; +$$ LANGUAGE plpgsql; + +--! @brief Shared blocker helper returning jsonb. Identical to +--! encrypted_domain_unsupported_bool but typed for blockers shadowing +--! native operators whose result is jsonb (#>, -, #-, ||), so composed +--! expressions resolve and the body raises rather than failing earlier +--! with a misleading 'operator does not exist' on a boolean result. +--! @param type_name Domain type name (eql_v3.*) +--! @param operator_name Operator symbol (#>, -, #-, ||, etc.) +--! @return jsonb (never returns; always raises) +CREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_jsonb(type_name text, operator_name text) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name; +END; +$$ LANGUAGE plpgsql; + +--! @brief Shared blocker helper returning text. Identical to +--! encrypted_domain_unsupported_bool but typed for blockers shadowing +--! the native #>> operator whose result is text. +--! @param type_name Domain type name (eql_v3.*) +--! @param operator_name Operator symbol (#>>) +--! @return text (never returns; always raises) +CREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_text(type_name text, operator_name text) +RETURNS text +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name; +END; +$$ LANGUAGE plpgsql; + +--! @file v3/sem/hmac_256/functions.sql +--! @brief HMAC-SHA256 index-term extraction from a jsonb payload (eql_v3 SEM). --! ---! Composite type containing an array of ORE block terms. The array is stored ---! in the 'ob' field of encrypted data payloads. +--! jsonb-only subset of src/hmac_256/functions.sql. The encrypted-column and +--! ste_vec-entry overloads are intentionally omitted — the eql_v3 scalar +--! domains extract from the jsonb payload directly via a cast to the domain. +--! (Doc comments deliberately avoid naming eql_v2 symbols so the +--! self-containment grep stays clean.) + +--! @brief Extract HMAC-SHA256 index term from JSONB payload --! ---! @note Transient type used only during query execution. -CREATE TYPE eql_v3_internal.ore_block_256 AS ( - terms eql_v3_internal.ore_block_256_term[] -); +--! Inlinable single-statement SQL — the planner can fold this into the calling +--! query so functional hash/btree indexes built on `eql_v3_internal.eq_term(col)` +--! (which calls this) engage structurally. +--! +--! @param val jsonb containing encrypted EQL payload +--! @return eql_v3_internal.hmac_256 HMAC-SHA256 hash value, or NULL when `hm` is absent +CREATE FUNCTION eql_v3_internal.hmac_256(val jsonb) + RETURNS eql_v3_internal.hmac_256 + LANGUAGE sql + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT (val ->> 'hm')::eql_v3_internal.hmac_256 +$$; + + +--! @brief Check if JSONB payload contains HMAC-SHA256 index term +--! +--! @param val jsonb containing encrypted EQL payload +--! @return boolean True if 'hm' field is present and non-null +CREATE FUNCTION eql_v3_internal.has_hmac_256(val jsonb) + RETURNS boolean + LANGUAGE sql + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT (val ->> 'hm') IS NOT NULL +$$; + +--! @file v3/sem/ope_cllw/functions.sql +--! @brief CLLW OPE index-term extraction from a jsonb payload (eql_v3 SEM). + +--! @brief Extract CLLW OPE index term from JSONB payload +--! +--! Returns the CLLW OPE ciphertext from the `op` field of an encrypted scalar +--! payload, hex-decoded to the bytea-backed eql_v3_internal.ope_cllw domain. +--! +--! Inlinable single-statement SQL — the body is a strict expression of the +--! argument (`->>` and `decode` are both STRICT), so the planner folds this +--! into the calling query and functional btree indexes built on +--! `eql_v3.ord_term(col)` (which calls this) engage structurally, the +--! same way the hmac_256 equality chain does. +--! +--! **Missing-`op` semantics**: `val ->> 'op'` is NULL when `op` is absent and +--! the strict chain propagates it, so the extractor returns SQL NULL and +--! btree's NULL handling filters those rows from range queries. +--! +--! @param val jsonb containing encrypted EQL payload +--! @return eql_v3_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when `op` is +--! absent +CREATE FUNCTION eql_v3_internal.ope_cllw(val jsonb) + RETURNS eql_v3_internal.ope_cllw + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT decode(val ->> 'op', 'hex')::eql_v3_internal.ope_cllw +$$; + +COMMENT ON FUNCTION eql_v3_internal.ope_cllw(jsonb) IS + 'eql-inline-critical: raw-jsonb CLLW OPE extractor; must stay inlinable (unpinned search_path)'; --! @file v3/sem/ore_block_256/functions.sql --! @brief ORE block construction, extraction, and comparison (eql_v3 SEM). @@ -481,210 +662,6 @@ AS $$ END $$ LANGUAGE plpgsql; ---! @file v3/sem/ope_cllw/types.sql ---! @brief CLLW OPE index term type for scalar range queries (eql_v3 SEM) ---! ---! Domain type representing a CLLW (Copyless Logarithmic Width) ---! Order-Preserving Encryption term. The ciphertext is stored hex-encoded in ---! the `op` field of encrypted scalar payloads (the `_ord_ope` domains); the ---! domain carries the hex-decoded bytes. ---! ---! A DOMAIN over bytea, not a composite: the OPE ciphertext is ---! order-preserving under plain byte comparison, so the domain inherits ---! bytea's native comparison operators and DEFAULT btree operator class ---! outright — no hand-written operators, comparator, or operator class (the ---! same pattern as eql_v3_internal.hmac_256 over text). That keeps the whole ---! comparison chain inlinable, so a functional btree index on ---! `eql_v3.ord_term(col)` engages structurally for the `_ord` / `_ord_ope` ---! domains' comparison operators. Contrast eql_v3_internal.ore_cllw (`oc`), the SteVec ---! CLLW-*ORE* composite compared by a custom per-byte protocol. ---! ---! @note Transient type used only during query execution. ---! @see eql_v3_internal.ope_cllw -CREATE DOMAIN eql_v3_internal.ope_cllw AS bytea; - ---! @file v3/sem/hmac_256/types.sql ---! @brief HMAC-SHA256 index term type (eql_v3 SEM) ---! ---! Domain type representing HMAC-SHA256 hash values. Used for exact-match ---! encrypted searches. The hash is stored in the 'hm' field of encrypted data ---! payloads. Self-contained eql_v3 copy (design D1/D3); the eql_v2 original is ---! unchanged. ---! ---! @note Transient type used only during query execution. -CREATE DOMAIN eql_v3_internal.hmac_256 AS text; - ---! @file v3/sem/bloom_filter/types.sql ---! @brief Self-contained eql_v3 Bloom-filter SEM index-term type. - ---! @brief Bloom-filter index term: a bit array stored as smallint[]. ---! ---! Backs the `match` capability (`@>` / `<@`) on `eql_v3_internal.text_match`. The ---! filter is read from the `bf` field of an encrypted jsonb payload. Native ---! `smallint[]` array-containment (`@>`/`<@`) is inherited through the domain, ---! so this type needs no custom operators. ---! ---! @note Self-contained: references no eql_v2 symbol. -CREATE DOMAIN eql_v3_internal.bloom_filter AS smallint[]; --- AUTOMATICALLY GENERATED FILE. - ---! @file v3/scalars/timestamp/timestamp_types.sql ---! @brief Encrypted-domain types for timestamp. - -DO $$ -BEGIN - --! @brief Encrypted domain public.eql_v3_timestamp. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_timestamp' AND typnamespace = 'public'::regnamespace - ) THEN - CREATE DOMAIN public.eql_v3_timestamp AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN public.eql_v3_timestamp IS 'EQL encrypted timestamp (storage only)'; - - --! @brief Encrypted domain public.eql_v3_timestamp_eq. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_timestamp_eq' AND typnamespace = 'public'::regnamespace - ) THEN - CREATE DOMAIN public.eql_v3_timestamp_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN public.eql_v3_timestamp_eq IS 'EQL encrypted timestamp (equality)'; - - --! @brief Encrypted domain public.eql_v3_timestamp_ord_ore. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_timestamp_ord_ore' AND typnamespace = 'public'::regnamespace - ) THEN - CREATE DOMAIN public.eql_v3_timestamp_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN public.eql_v3_timestamp_ord_ore IS 'EQL encrypted timestamp (equality, ordering)'; - - --! @brief Encrypted domain public.eql_v3_timestamp_ord. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_timestamp_ord' AND typnamespace = 'public'::regnamespace - ) THEN - CREATE DOMAIN public.eql_v3_timestamp_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'op' - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN public.eql_v3_timestamp_ord IS 'EQL encrypted timestamp (equality, ordering)'; - - --! @brief Encrypted domain public.eql_v3_timestamp_ord_ope. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_timestamp_ord_ope' AND typnamespace = 'public'::regnamespace - ) THEN - CREATE DOMAIN public.eql_v3_timestamp_ord_ope AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'op' - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN public.eql_v3_timestamp_ord_ope IS 'EQL encrypted timestamp (equality, ordering)'; -END -$$; - ---! @file v3/scalars/functions.sql ---! @brief Shared blocker helper for the eql_v3 encrypted-domain families. ---! ---! Per-domain wrapper functions live in src/v3/scalars//. ---! Blockers in those files delegate to encrypted_domain_unsupported_bool ---! so every domain raises a uniform domain-specific error rather than ---! letting an unsupported operator fall through to native jsonb ---! behaviour. - ---! @brief Shared blocker helper. Raises 'operator X is not supported ---! for TYPE' so unsupported domain operators surface a clear ---! error rather than fall through to native jsonb behaviour. ---! @param type_name Domain type name (eql_v3.*) ---! @param operator_name Operator symbol (=, <, @>, ->, etc.) ---! @return boolean (never returns; always raises) -CREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_bool(type_name text, operator_name text) -RETURNS boolean -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name; -END; -$$ LANGUAGE plpgsql; - ---! @brief Shared blocker helper returning jsonb. Identical to ---! encrypted_domain_unsupported_bool but typed for blockers shadowing ---! native operators whose result is jsonb (#>, -, #-, ||), so composed ---! expressions resolve and the body raises rather than failing earlier ---! with a misleading 'operator does not exist' on a boolean result. ---! @param type_name Domain type name (eql_v3.*) ---! @param operator_name Operator symbol (#>, -, #-, ||, etc.) ---! @return jsonb (never returns; always raises) -CREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_jsonb(type_name text, operator_name text) -RETURNS jsonb -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name; -END; -$$ LANGUAGE plpgsql; - ---! @brief Shared blocker helper returning text. Identical to ---! encrypted_domain_unsupported_bool but typed for blockers shadowing ---! the native #>> operator whose result is text. ---! @param type_name Domain type name (eql_v3.*) ---! @param operator_name Operator symbol (#>>) ---! @return text (never returns; always raises) -CREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_text(type_name text, operator_name text) -RETURNS text -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name; -END; -$$ LANGUAGE plpgsql; - --! @file v3/sem/ore_block_256/operators.sql --! @brief Comparison operators on eql_v3_internal.ore_block_256. --! @@ -861,88 +838,19 @@ CREATE OPERATOR public.>= ( RESTRICT = scalargesel, JOIN = scalargejoinsel ); - ---! @file v3/sem/ope_cllw/functions.sql ---! @brief CLLW OPE index-term extraction from a jsonb payload (eql_v3 SEM). - ---! @brief Extract CLLW OPE index term from JSONB payload ---! ---! Returns the CLLW OPE ciphertext from the `op` field of an encrypted scalar ---! payload, hex-decoded to the bytea-backed eql_v3_internal.ope_cllw domain. ---! ---! Inlinable single-statement SQL — the body is a strict expression of the ---! argument (`->>` and `decode` are both STRICT), so the planner folds this ---! into the calling query and functional btree indexes built on ---! `eql_v3.ord_term(col)` (which calls this) engage structurally, the ---! same way the hmac_256 equality chain does. ---! ---! **Missing-`op` semantics**: `val ->> 'op'` is NULL when `op` is absent and ---! the strict chain propagates it, so the extractor returns SQL NULL and ---! btree's NULL handling filters those rows from range queries. ---! ---! @param val jsonb containing encrypted EQL payload ---! @return eql_v3_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when `op` is ---! absent -CREATE FUNCTION eql_v3_internal.ope_cllw(val jsonb) - RETURNS eql_v3_internal.ope_cllw - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT decode(val ->> 'op', 'hex')::eql_v3_internal.ope_cllw -$$; - -COMMENT ON FUNCTION eql_v3_internal.ope_cllw(jsonb) IS - 'eql-inline-critical: raw-jsonb CLLW OPE extractor; must stay inlinable (unpinned search_path)'; - ---! @file v3/sem/hmac_256/functions.sql ---! @brief HMAC-SHA256 index-term extraction from a jsonb payload (eql_v3 SEM). ---! ---! jsonb-only subset of src/hmac_256/functions.sql. The encrypted-column and ---! ste_vec-entry overloads are intentionally omitted — the eql_v3 scalar ---! domains extract from the jsonb payload directly via a cast to the domain. ---! (Doc comments deliberately avoid naming eql_v2 symbols so the ---! self-containment grep stays clean.) - ---! @brief Extract HMAC-SHA256 index term from JSONB payload ---! ---! Inlinable single-statement SQL — the planner can fold this into the calling ---! query so functional hash/btree indexes built on `eql_v3_internal.eq_term(col)` ---! (which calls this) engage structurally. ---! ---! @param val jsonb containing encrypted EQL payload ---! @return eql_v3_internal.hmac_256 HMAC-SHA256 hash value, or NULL when `hm` is absent -CREATE FUNCTION eql_v3_internal.hmac_256(val jsonb) - RETURNS eql_v3_internal.hmac_256 - LANGUAGE sql - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT (val ->> 'hm')::eql_v3_internal.hmac_256 -$$; - - ---! @brief Check if JSONB payload contains HMAC-SHA256 index term ---! ---! @param val jsonb containing encrypted EQL payload ---! @return boolean True if 'hm' field is present and non-null -CREATE FUNCTION eql_v3_internal.has_hmac_256(val jsonb) - RETURNS boolean - LANGUAGE sql - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT (val ->> 'hm') IS NOT NULL -$$; -- AUTOMATICALLY GENERATED FILE. ---! @file v3/scalars/text/text_types.sql ---! @brief Encrypted-domain types for text. +--! @file v3/scalars/real/real_types.sql +--! @brief Encrypted-domain types for real. DO $$ BEGIN - --! @brief Encrypted domain public.eql_v3_text. + --! @brief Encrypted domain public.eql_v3_real. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_text' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_real' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_text AS jsonb + CREATE DOMAIN public.eql_v3_real AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -952,14 +860,14 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_text IS 'EQL encrypted text (storage only)'; + COMMENT ON DOMAIN public.eql_v3_real IS 'EQL encrypted real (storage only)'; - --! @brief Encrypted domain public.eql_v3_text_eq. + --! @brief Encrypted domain public.eql_v3_real_eq. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_text_eq' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_real_eq' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_text_eq AS jsonb + CREATE DOMAIN public.eql_v3_real_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -970,198 +878,1023 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_text_eq IS 'EQL encrypted text (equality)'; + COMMENT ON DOMAIN public.eql_v3_real_eq IS 'EQL encrypted real (equality)'; - --! @brief Encrypted domain public.eql_v3_text_match. + --! @brief Encrypted domain public.eql_v3_real_ord_ore. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_text_match' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_real_ord_ore' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_text_match AS jsonb + CREATE DOMAIN public.eql_v3_real_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' - AND VALUE ? 'bf' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 AND VALUE->>'v' = '3' ); END IF; - COMMENT ON DOMAIN public.eql_v3_text_match IS 'EQL encrypted text (containment)'; + COMMENT ON DOMAIN public.eql_v3_real_ord_ore IS 'EQL encrypted real (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_text_ord_ore. + --! @brief Encrypted domain public.eql_v3_real_ord. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_text_ord_ore' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_real_ord' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_text_ord_ore AS jsonb + CREATE DOMAIN public.eql_v3_real_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE ? 'op' AND VALUE->>'v' = '3' ); END IF; - COMMENT ON DOMAIN public.eql_v3_text_ord_ore IS 'EQL encrypted text (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_real_ord IS 'EQL encrypted real (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_text_ord. + --! @brief Encrypted domain public.eql_v3_real_ord_ope. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_text_ord' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_real_ord_ope' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_text_ord AS jsonb + CREATE DOMAIN public.eql_v3_real_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' - AND VALUE ? 'hm' AND VALUE ? 'op' AND VALUE->>'v' = '3' ); END IF; - COMMENT ON DOMAIN public.eql_v3_text_ord IS 'EQL encrypted text (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_real_ord_ope IS 'EQL encrypted real (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. - --! @brief Encrypted domain public.eql_v3_text_ord_ope. +--! @file encrypted_domain/real/real_ord_ore_functions.sql +--! @brief Functions for public.eql_v3_real_ord_ore. + +--! @brief Index extractor for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_real_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) = eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) <> eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) < eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) <= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) > eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) >= eql_v3.ord_term_ore(b) $$; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param selector text +--! @return public.eql_v3_real_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ore, selector text) +RETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param selector integer +--! @return public.eql_v3_real_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ore, selector integer) +RETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a jsonb +--! @param selector public.eql_v3_real_ord_ore +--! @return public.eql_v3_real_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_ord_ore) +RETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a jsonb +--! @param selector public.eql_v3_real_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_real_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b public.eql_v3_real_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_real_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/smallint/smallint_types.sql +--! @brief Encrypted-domain types for smallint. + +DO $$ +BEGIN + --! @brief Encrypted domain public.eql_v3_smallint. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_text_ord_ope' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_smallint' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_text_ord_ope AS jsonb + CREATE DOMAIN public.eql_v3_smallint AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE ? 'op' AND VALUE->>'v' = '3' ); END IF; - COMMENT ON DOMAIN public.eql_v3_text_ord_ope IS 'EQL encrypted text (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_smallint IS 'EQL encrypted smallint (storage only)'; - --! @brief Encrypted domain public.eql_v3_text_search_ore. + --! @brief Encrypted domain public.eql_v3_smallint_eq. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_text_search_ore' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_smallint_eq' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_text_search_ore AS jsonb + CREATE DOMAIN public.eql_v3_smallint_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' AND VALUE ? 'hm' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.eql_v3_smallint_eq IS 'EQL encrypted smallint (equality)'; + + --! @brief Encrypted domain public.eql_v3_smallint_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'eql_v3_smallint_ord_ore' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.eql_v3_smallint_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' AND VALUE ? 'ob' - AND VALUE ? 'bf' AND jsonb_typeof(VALUE -> 'ob') = 'array' AND jsonb_array_length(VALUE -> 'ob') > 0 AND VALUE->>'v' = '3' ); END IF; - COMMENT ON DOMAIN public.eql_v3_text_search_ore IS 'EQL encrypted text (equality, ordering, containment)'; + COMMENT ON DOMAIN public.eql_v3_smallint_ord_ore IS 'EQL encrypted smallint (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_text_search. + --! @brief Encrypted domain public.eql_v3_smallint_ord. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_text_search' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_smallint_ord' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_text_search AS jsonb + CREATE DOMAIN public.eql_v3_smallint_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'op' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.eql_v3_smallint_ord IS 'EQL encrypted smallint (equality, ordering)'; + + --! @brief Encrypted domain public.eql_v3_smallint_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'eql_v3_smallint_ord_ope' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.eql_v3_smallint_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' - AND VALUE ? 'hm' AND VALUE ? 'op' - AND VALUE ? 'bf' AND VALUE->>'v' = '3' ); END IF; - COMMENT ON DOMAIN public.eql_v3_text_search IS 'EQL encrypted text (equality, ordering, containment)'; + COMMENT ON DOMAIN public.eql_v3_smallint_ord_ope IS 'EQL encrypted smallint (equality, ordering)'; END $$; +-- AUTOMATICALLY GENERATED FILE. ---! @file v3/sem/bloom_filter/functions.sql ---! @brief Extractor for the eql_v3 Bloom-filter SEM index term. ---! ---! jsonb-only subset of src/bloom_filter/functions.sql. The encrypted-column ---! overloads are intentionally omitted — the eql_v3 scalar domains extract from ---! the jsonb payload directly via a cast to the domain. (Doc comments ---! deliberately avoid naming eql_v2 symbols so the self-containment grep stays ---! clean.) +--! @file encrypted_domain/smallint/smallint_eq_functions.sql +--! @brief Functions for public.eql_v3_smallint_eq. ---! @brief Test whether a jsonb payload carries a Bloom-filter (`bf`) term. ---! ---! @param val jsonb The encrypted payload. ---! @return boolean True when the `bf` key is present and non-null. ---! ---! @internal Defined for parity with the eql_v3 SEM index-term predicates ---! (`has_hmac_256` / `has_ore_block_256`); it is not currently called by ---! the extractor below, which gates on value-shape inline, nor by the generated ---! domain CHECK, which tests `bf` presence via the envelope-key skeleton. Kept ---! as the canonical presence test for callers that need one. -CREATE FUNCTION eql_v3_internal.has_bloom_filter(val jsonb) - RETURNS boolean - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - BEGIN - RETURN val ? 'bf' AND val ->> 'bf' IS NOT NULL; - END; -$$ LANGUAGE plpgsql; +--! @brief Index extractor for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_smallint_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Extract the Bloom-filter index term from a jsonb payload. ---! ---! Inlinable single-statement SQL — the planner can fold this into the calling ---! query so the functional GIN index built on `eql_v3_internal.match_term(col)` (which ---! calls this) engages structurally. Mirrors `eql_v3_internal.hmac_256(jsonb)`: no RAISE ---! and no pinned `search_path`. Returns NULL when `bf` is absent or present but ---! not a json array, rather than raising. The `text_match` domain CHECK ---! guarantees the `bf` *key* is present but not that it is an array, so a ---! non-array `bf` (e.g. `{"bf": null}`) can reach here even on a typed value; ---! gating on `jsonb_typeof(...) = 'array'` returns NULL for that case — and for ---! raw jsonb outside the domain — instead of erroring inside ---! `jsonb_array_elements`. NULL, like the HMAC extractor, is the right answer. An ---! empty `bf` array yields an empty filter (contains nothing, contained by ---! everything), matching set-containment semantics. ---! ---! @param val jsonb The encrypted payload. ---! @return eql_v3_internal.bloom_filter The `bf` array as a smallint[] domain value, or ---! NULL when `bf` is absent or not a json array. -CREATE FUNCTION eql_v3_internal.bloom_filter(val jsonb) - RETURNS eql_v3_internal.bloom_filter - LANGUAGE sql - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT CASE WHEN jsonb_typeof(val -> 'bf') = 'array' - THEN ARRAY(SELECT jsonb_array_elements(val -> 'bf'))::eql_v3_internal.bloom_filter - END -$$; +--! @brief Operator wrapper for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_smallint_eq) $$; + +--! @brief Operator wrapper for public.eql_v3_smallint_eq. +--! @param a jsonb +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_smallint_eq) $$; + +--! @brief Operator wrapper for public.eql_v3_smallint_eq. +--! @param a jsonb +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a jsonb +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a jsonb +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a jsonb +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a jsonb +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a jsonb +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a jsonb +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param selector text +--! @return public.eql_v3_smallint_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_eq, selector text) +RETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param selector integer +--! @return public.eql_v3_smallint_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_eq, selector integer) +RETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a jsonb +--! @param selector public.eql_v3_smallint_eq +--! @return public.eql_v3_smallint_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint_eq) +RETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a jsonb +--! @param selector public.eql_v3_smallint_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a jsonb +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a jsonb +--! @param b public.eql_v3_smallint_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file v3/scalars/smallint/smallint_types.sql ---! @brief Encrypted-domain types for smallint. +--! @file v3/scalars/date/date_types.sql +--! @brief Encrypted-domain types for date. DO $$ BEGIN - --! @brief Encrypted domain public.eql_v3_smallint. + --! @brief Encrypted domain public.eql_v3_date. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_smallint' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_date' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_smallint AS jsonb + CREATE DOMAIN public.eql_v3_date AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1171,14 +1904,14 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_smallint IS 'EQL encrypted smallint (storage only)'; + COMMENT ON DOMAIN public.eql_v3_date IS 'EQL encrypted date (storage only)'; - --! @brief Encrypted domain public.eql_v3_smallint_eq. + --! @brief Encrypted domain public.eql_v3_date_eq. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_smallint_eq' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_date_eq' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_smallint_eq AS jsonb + CREATE DOMAIN public.eql_v3_date_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1189,14 +1922,14 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_smallint_eq IS 'EQL encrypted smallint (equality)'; + COMMENT ON DOMAIN public.eql_v3_date_eq IS 'EQL encrypted date (equality)'; - --! @brief Encrypted domain public.eql_v3_smallint_ord_ore. + --! @brief Encrypted domain public.eql_v3_date_ord_ore. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_smallint_ord_ore' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_date_ord_ore' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_smallint_ord_ore AS jsonb + CREATE DOMAIN public.eql_v3_date_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1209,14 +1942,14 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_smallint_ord_ore IS 'EQL encrypted smallint (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_date_ord_ore IS 'EQL encrypted date (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_smallint_ord. + --! @brief Encrypted domain public.eql_v3_date_ord. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_smallint_ord' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_date_ord' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_smallint_ord AS jsonb + CREATE DOMAIN public.eql_v3_date_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1227,14 +1960,14 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_smallint_ord IS 'EQL encrypted smallint (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_date_ord IS 'EQL encrypted date (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_smallint_ord_ope. + --! @brief Encrypted domain public.eql_v3_date_ord_ope. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_smallint_ord_ope' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_date_ord_ope' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_smallint_ord_ope AS jsonb + CREATE DOMAIN public.eql_v3_date_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1245,22 +1978,22 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_smallint_ord_ope IS 'EQL encrypted smallint (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_date_ord_ope IS 'EQL encrypted date (equality, ordering)'; END $$; -- AUTOMATICALLY GENERATED FILE. ---! @file v3/scalars/real/real_types.sql ---! @brief Encrypted-domain types for real. +--! @file v3/scalars/numeric/numeric_types.sql +--! @brief Encrypted-domain types for numeric. DO $$ BEGIN - --! @brief Encrypted domain public.eql_v3_real. + --! @brief Encrypted domain public.eql_v3_numeric. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_real' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_numeric' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_real AS jsonb + CREATE DOMAIN public.eql_v3_numeric AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1270,14 +2003,14 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_real IS 'EQL encrypted real (storage only)'; + COMMENT ON DOMAIN public.eql_v3_numeric IS 'EQL encrypted numeric (storage only)'; - --! @brief Encrypted domain public.eql_v3_real_eq. + --! @brief Encrypted domain public.eql_v3_numeric_eq. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_real_eq' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_numeric_eq' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_real_eq AS jsonb + CREATE DOMAIN public.eql_v3_numeric_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1288,14 +2021,14 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_real_eq IS 'EQL encrypted real (equality)'; + COMMENT ON DOMAIN public.eql_v3_numeric_eq IS 'EQL encrypted numeric (equality)'; - --! @brief Encrypted domain public.eql_v3_real_ord_ore. + --! @brief Encrypted domain public.eql_v3_numeric_ord_ore. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_real_ord_ore' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_numeric_ord_ore' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_real_ord_ore AS jsonb + CREATE DOMAIN public.eql_v3_numeric_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1308,14 +2041,14 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_real_ord_ore IS 'EQL encrypted real (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_numeric_ord_ore IS 'EQL encrypted numeric (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_real_ord. + --! @brief Encrypted domain public.eql_v3_numeric_ord. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_real_ord' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_numeric_ord' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_real_ord AS jsonb + CREATE DOMAIN public.eql_v3_numeric_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1326,14 +2059,14 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_real_ord IS 'EQL encrypted real (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_numeric_ord IS 'EQL encrypted numeric (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_real_ord_ope. + --! @brief Encrypted domain public.eql_v3_numeric_ord_ope. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_real_ord_ope' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_numeric_ord_ope' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_real_ord_ope AS jsonb + CREATE DOMAIN public.eql_v3_numeric_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1344,22 +2077,22 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_real_ord_ope IS 'EQL encrypted real (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_numeric_ord_ope IS 'EQL encrypted numeric (equality, ordering)'; END $$; -- AUTOMATICALLY GENERATED FILE. ---! @file v3/scalars/numeric/numeric_types.sql ---! @brief Encrypted-domain types for numeric. +--! @file v3/scalars/double/double_types.sql +--! @brief Encrypted-domain types for double. DO $$ BEGIN - --! @brief Encrypted domain public.eql_v3_numeric. + --! @brief Encrypted domain public.eql_v3_double. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_numeric' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_double' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_numeric AS jsonb + CREATE DOMAIN public.eql_v3_double AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1369,14 +2102,14 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_numeric IS 'EQL encrypted numeric (storage only)'; + COMMENT ON DOMAIN public.eql_v3_double IS 'EQL encrypted double (storage only)'; - --! @brief Encrypted domain public.eql_v3_numeric_eq. + --! @brief Encrypted domain public.eql_v3_double_eq. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_numeric_eq' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_double_eq' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_numeric_eq AS jsonb + CREATE DOMAIN public.eql_v3_double_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1387,14 +2120,14 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_numeric_eq IS 'EQL encrypted numeric (equality)'; + COMMENT ON DOMAIN public.eql_v3_double_eq IS 'EQL encrypted double (equality)'; - --! @brief Encrypted domain public.eql_v3_numeric_ord_ore. + --! @brief Encrypted domain public.eql_v3_double_ord_ore. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_numeric_ord_ore' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_double_ord_ore' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_numeric_ord_ore AS jsonb + CREATE DOMAIN public.eql_v3_double_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1407,14 +2140,14 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_numeric_ord_ore IS 'EQL encrypted numeric (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_double_ord_ore IS 'EQL encrypted double (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_numeric_ord. + --! @brief Encrypted domain public.eql_v3_double_ord. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_numeric_ord' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_double_ord' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_numeric_ord AS jsonb + CREATE DOMAIN public.eql_v3_double_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1425,14 +2158,14 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_numeric_ord IS 'EQL encrypted numeric (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_double_ord IS 'EQL encrypted double (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_numeric_ord_ope. + --! @brief Encrypted domain public.eql_v3_double_ord_ope. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_numeric_ord_ope' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_double_ord_ope' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_numeric_ord_ope AS jsonb + CREATE DOMAIN public.eql_v3_double_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1443,11 +2176,440 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_numeric_ord_ope IS 'EQL encrypted numeric (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_double_ord_ope IS 'EQL encrypted double (equality, ordering)'; END $$; -- AUTOMATICALLY GENERATED FILE. +--! @file encrypted_domain/double/double_eq_functions.sql +--! @brief Functions for public.eql_v3_double_eq. + +--! @brief Index extractor for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_double_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b public.eql_v3_double_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_double_eq) $$; + +--! @brief Operator wrapper for public.eql_v3_double_eq. +--! @param a jsonb +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b public.eql_v3_double_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_double_eq) $$; + +--! @brief Operator wrapper for public.eql_v3_double_eq. +--! @param a jsonb +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b public.eql_v3_double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a jsonb +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b public.eql_v3_double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a jsonb +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b public.eql_v3_double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a jsonb +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b public.eql_v3_double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a jsonb +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b public.eql_v3_double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a jsonb +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b public.eql_v3_double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a jsonb +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param selector text +--! @return public.eql_v3_double_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_eq, selector text) +RETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param selector integer +--! @return public.eql_v3_double_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_eq, selector integer) +RETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a jsonb +--! @param selector public.eql_v3_double_eq +--! @return public.eql_v3_double_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double_eq) +RETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a jsonb +--! @param selector public.eql_v3_double_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_eq, b public.eql_v3_double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a jsonb +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b public.eql_v3_double_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_eq, b public.eql_v3_double_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a jsonb +--! @param b public.eql_v3_double_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + --! @file v3/scalars/integer/integer_types.sql --! @brief Encrypted-domain types for integer. @@ -1547,17 +2709,17 @@ END $$; -- AUTOMATICALLY GENERATED FILE. ---! @file v3/scalars/double/double_types.sql ---! @brief Encrypted-domain types for double. - +--! @file v3/scalars/timestamp/timestamp_types.sql +--! @brief Encrypted-domain types for timestamp. + DO $$ BEGIN - --! @brief Encrypted domain public.eql_v3_double. + --! @brief Encrypted domain public.eql_v3_timestamp. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_double' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_timestamp' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_double AS jsonb + CREATE DOMAIN public.eql_v3_timestamp AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1567,14 +2729,14 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_double IS 'EQL encrypted double (storage only)'; + COMMENT ON DOMAIN public.eql_v3_timestamp IS 'EQL encrypted timestamp (storage only)'; - --! @brief Encrypted domain public.eql_v3_double_eq. + --! @brief Encrypted domain public.eql_v3_timestamp_eq. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_double_eq' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_timestamp_eq' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_double_eq AS jsonb + CREATE DOMAIN public.eql_v3_timestamp_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1585,14 +2747,14 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_double_eq IS 'EQL encrypted double (equality)'; + COMMENT ON DOMAIN public.eql_v3_timestamp_eq IS 'EQL encrypted timestamp (equality)'; - --! @brief Encrypted domain public.eql_v3_double_ord_ore. + --! @brief Encrypted domain public.eql_v3_timestamp_ord_ore. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_double_ord_ore' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_timestamp_ord_ore' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_double_ord_ore AS jsonb + CREATE DOMAIN public.eql_v3_timestamp_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1605,14 +2767,14 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_double_ord_ore IS 'EQL encrypted double (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_timestamp_ord_ore IS 'EQL encrypted timestamp (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_double_ord. + --! @brief Encrypted domain public.eql_v3_timestamp_ord. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_double_ord' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_timestamp_ord' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_double_ord AS jsonb + CREATE DOMAIN public.eql_v3_timestamp_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1623,14 +2785,14 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_double_ord IS 'EQL encrypted double (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_timestamp_ord IS 'EQL encrypted timestamp (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_double_ord_ope. + --! @brief Encrypted domain public.eql_v3_timestamp_ord_ope. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_double_ord_ope' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_timestamp_ord_ope' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_double_ord_ope AS jsonb + CREATE DOMAIN public.eql_v3_timestamp_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1641,22 +2803,22 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_double_ord_ope IS 'EQL encrypted double (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_timestamp_ord_ope IS 'EQL encrypted timestamp (equality, ordering)'; END $$; -- AUTOMATICALLY GENERATED FILE. ---! @file v3/scalars/date/date_types.sql ---! @brief Encrypted-domain types for date. +--! @file v3/scalars/text/text_types.sql +--! @brief Encrypted-domain types for text. DO $$ BEGIN - --! @brief Encrypted domain public.eql_v3_date. + --! @brief Encrypted domain public.eql_v3_text. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_date' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_text' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_date AS jsonb + CREATE DOMAIN public.eql_v3_text AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1666,14 +2828,14 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_date IS 'EQL encrypted date (storage only)'; + COMMENT ON DOMAIN public.eql_v3_text IS 'EQL encrypted text (storage only)'; - --! @brief Encrypted domain public.eql_v3_date_eq. + --! @brief Encrypted domain public.eql_v3_text_eq. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_date_eq' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_text_eq' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_date_eq AS jsonb + CREATE DOMAIN public.eql_v3_text_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1684,4779 +2846,4726 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_date_eq IS 'EQL encrypted date (equality)'; + COMMENT ON DOMAIN public.eql_v3_text_eq IS 'EQL encrypted text (equality)'; - --! @brief Encrypted domain public.eql_v3_date_ord_ore. + --! @brief Encrypted domain public.eql_v3_text_match. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_date_ord_ore' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_text_match' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_date_ord_ore AS jsonb + CREATE DOMAIN public.eql_v3_text_match AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE ? 'bf' AND VALUE->>'v' = '3' ); END IF; - COMMENT ON DOMAIN public.eql_v3_date_ord_ore IS 'EQL encrypted date (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_text_match IS 'EQL encrypted text (matching)'; - --! @brief Encrypted domain public.eql_v3_date_ord. + --! @brief Encrypted domain public.eql_v3_text_ord_ore. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_date_ord' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_text_ord_ore' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_date_ord AS jsonb + CREATE DOMAIN public.eql_v3_text_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' - AND VALUE ? 'op' + AND VALUE ? 'hm' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 AND VALUE->>'v' = '3' ); END IF; - COMMENT ON DOMAIN public.eql_v3_date_ord IS 'EQL encrypted date (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_text_ord_ore IS 'EQL encrypted text (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_date_ord_ope. + --! @brief Encrypted domain public.eql_v3_text_ord. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_date_ord_ope' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_text_ord' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_date_ord_ope AS jsonb + CREATE DOMAIN public.eql_v3_text_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' + AND VALUE ? 'hm' AND VALUE ? 'op' AND VALUE->>'v' = '3' ); END IF; - COMMENT ON DOMAIN public.eql_v3_date_ord_ope IS 'EQL encrypted date (equality, ordering)'; -END -$$; --- AUTOMATICALLY GENERATED FILE. - ---! @file v3/scalars/bigint/bigint_types.sql ---! @brief Encrypted-domain types for bigint. - -DO $$ -BEGIN - --! @brief Encrypted domain public.eql_v3_bigint. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_bigint' AND typnamespace = 'public'::regnamespace - ) THEN - CREATE DOMAIN public.eql_v3_bigint AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN public.eql_v3_bigint IS 'EQL encrypted bigint (storage only)'; + COMMENT ON DOMAIN public.eql_v3_text_ord IS 'EQL encrypted text (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_bigint_eq. + --! @brief Encrypted domain public.eql_v3_text_ord_ope. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_bigint_eq' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_text_ord_ope' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_bigint_eq AS jsonb + CREATE DOMAIN public.eql_v3_text_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' AND VALUE ? 'hm' + AND VALUE ? 'op' AND VALUE->>'v' = '3' ); END IF; - COMMENT ON DOMAIN public.eql_v3_bigint_eq IS 'EQL encrypted bigint (equality)'; + COMMENT ON DOMAIN public.eql_v3_text_ord_ope IS 'EQL encrypted text (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_bigint_ord_ore. + --! @brief Encrypted domain public.eql_v3_text_search_ore. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_bigint_ord_ore' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_text_search_ore' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_bigint_ord_ore AS jsonb + CREATE DOMAIN public.eql_v3_text_search_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' + AND VALUE ? 'hm' AND VALUE ? 'ob' + AND VALUE ? 'bf' AND jsonb_typeof(VALUE -> 'ob') = 'array' AND jsonb_array_length(VALUE -> 'ob') > 0 AND VALUE->>'v' = '3' ); END IF; - COMMENT ON DOMAIN public.eql_v3_bigint_ord_ore IS 'EQL encrypted bigint (equality, ordering)'; - - --! @brief Encrypted domain public.eql_v3_bigint_ord. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_bigint_ord' AND typnamespace = 'public'::regnamespace - ) THEN - CREATE DOMAIN public.eql_v3_bigint_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'op' - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN public.eql_v3_bigint_ord IS 'EQL encrypted bigint (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_text_search_ore IS 'EQL encrypted text (equality, ordering, matching)'; - --! @brief Encrypted domain public.eql_v3_bigint_ord_ope. + --! @brief Encrypted domain public.eql_v3_text_search. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_bigint_ord_ope' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_text_search' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_bigint_ord_ope AS jsonb + CREATE DOMAIN public.eql_v3_text_search AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' + AND VALUE ? 'hm' AND VALUE ? 'op' + AND VALUE ? 'bf' AND VALUE->>'v' = '3' ); END IF; - COMMENT ON DOMAIN public.eql_v3_bigint_ord_ope IS 'EQL encrypted bigint (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_text_search IS 'EQL encrypted text (equality, ordering, matching)'; END $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/timestamp/timestamp_ord_ore_functions.sql ---! @brief Functions for public.eql_v3_timestamp_ord_ore. +--! @file encrypted_domain/text/text_ord_functions.sql +--! @brief Functions for public.eql_v3_text_ord. ---! @brief Index extractor for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_timestamp_ord_ore) -RETURNS eql_v3_internal.ore_block_256 +--! @brief Index extractor for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord) +RETURNS eql_v3_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Index extractor for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_ord) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @brief Operator wrapper for public.eql_v3_text_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @brief Operator wrapper for public.eql_v3_text_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_ord) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @brief Operator wrapper for public.eql_v3_text_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_ord) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @brief Operator wrapper for public.eql_v3_text_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_ord) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @brief Operator wrapper for public.eql_v3_text_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_ord) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @brief Operator wrapper for public.eql_v3_text_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param selector text ---! @return public.eql_v3_timestamp_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ore, selector text) -RETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$ +--! @return public.eql_v3_text_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord, selector text) +RETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param selector integer ---! @return public.eql_v3_timestamp_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ore, selector integer) -RETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$ +--! @return public.eql_v3_text_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord, selector integer) +RETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. --! @param a jsonb ---! @param selector public.eql_v3_timestamp_ord_ore ---! @return public.eql_v3_timestamp_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_ord_ore) -RETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$ +--! @param selector public.eql_v3_text_ord +--! @return public.eql_v3_text_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_ord) +RETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ore, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ore, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. --! @param a jsonb ---! @param selector public.eql_v3_timestamp_ord_ore +--! @param selector public.eql_v3_text_ord --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_ord) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b jsonpath +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a jsonb +--! @param b public.eql_v3_text_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_text_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ore, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b public.eql_v3_text_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_text_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; + +--! @file v3/sem/bloom_filter/functions.sql +--! @brief Extractor for the eql_v3 Bloom-filter SEM index term. +--! +--! jsonb-only subset of src/bloom_filter/functions.sql. The encrypted-column +--! overloads are intentionally omitted — the eql_v3 scalar domains extract from +--! the jsonb payload directly via a cast to the domain. (Doc comments +--! deliberately avoid naming eql_v2 symbols so the self-containment grep stays +--! clean.) + +--! @brief Test whether a jsonb payload carries a Bloom-filter (`bf`) term. +--! +--! @param val jsonb The encrypted payload. +--! @return boolean True when the `bf` key is present and non-null. +--! +--! @internal Defined for parity with the eql_v3 SEM index-term predicates +--! (`has_hmac_256` / `has_ore_block_256`); it is not currently called by +--! the extractor below, which gates on value-shape inline, nor by the generated +--! domain CHECK, which tests `bf` presence via the envelope-key skeleton. Kept +--! as the canonical presence test for callers that need one. +CREATE FUNCTION eql_v3_internal.has_bloom_filter(val jsonb) + RETURNS boolean + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + BEGIN + RETURN val ? 'bf' AND val ->> 'bf' IS NOT NULL; + END; +$$ LANGUAGE plpgsql; + +--! @brief Extract the Bloom-filter index term from a jsonb payload. +--! +--! Inlinable single-statement SQL — the planner can fold this into the calling +--! query so the functional GIN index built on `eql_v3_internal.match_term(col)` (which +--! calls this) engages structurally. Mirrors `eql_v3_internal.hmac_256(jsonb)`: no RAISE +--! and no pinned `search_path`. Returns NULL when `bf` is absent or present but +--! not a json array, rather than raising. The `text_match` domain CHECK +--! guarantees the `bf` *key* is present but not that it is an array, so a +--! non-array `bf` (e.g. `{"bf": null}`) can reach here even on a typed value; +--! gating on `jsonb_typeof(...) = 'array'` returns NULL for that case — and for +--! raw jsonb outside the domain — instead of erroring inside +--! `jsonb_array_elements`. NULL, like the HMAC extractor, is the right answer. An +--! empty `bf` array yields an empty filter (contains nothing, contained by +--! everything), matching set-containment semantics. +--! +--! @param val jsonb The encrypted payload. +--! @return eql_v3_internal.bloom_filter The `bf` array as a smallint[] domain value, or +--! NULL when `bf` is absent or not a json array. +CREATE FUNCTION eql_v3_internal.bloom_filter(val jsonb) + RETURNS eql_v3_internal.bloom_filter + LANGUAGE sql + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT CASE WHEN jsonb_typeof(val -> 'bf') = 'array' + THEN ARRAY(SELECT jsonb_array_elements(val -> 'bf'))::eql_v3_internal.bloom_filter + END +$$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/timestamp/timestamp_ord_ope_functions.sql ---! @brief Functions for public.eql_v3_timestamp_ord_ope. +--! @file encrypted_domain/timestamp/timestamp_eq_functions.sql +--! @brief Functions for public.eql_v3_timestamp_eq. ---! @brief Index extractor for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_timestamp_ord_ope) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_timestamp_eq) +RETURNS eql_v3_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Operator wrapper for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Operator wrapper for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_timestamp_eq) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @brief Operator wrapper for public.eql_v3_timestamp_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Operator wrapper for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Operator wrapper for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_timestamp_eq) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @brief Operator wrapper for public.eql_v3_timestamp_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) < eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) <= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) > eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) >= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param selector text ---! @return public.eql_v3_timestamp_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ope, selector text) -RETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$ +--! @return public.eql_v3_timestamp_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_eq, selector text) +RETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param selector integer ---! @return public.eql_v3_timestamp_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ope, selector integer) -RETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$ +--! @return public.eql_v3_timestamp_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_eq, selector integer) +RETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. --! @param a jsonb ---! @param selector public.eql_v3_timestamp_ord_ope ---! @return public.eql_v3_timestamp_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_ord_ope) -RETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$ +--! @param selector public.eql_v3_timestamp_eq +--! @return public.eql_v3_timestamp_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_eq) +RETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ope, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ope, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. --! @param a jsonb ---! @param selector public.eql_v3_timestamp_ord_ope +--! @param selector public.eql_v3_timestamp_eq --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_eq) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_ord_ope, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b jsonpath +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ope, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ope, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b public.eql_v3_timestamp_eq --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_eq --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/timestamp/timestamp_ord_functions.sql ---! @brief Functions for public.eql_v3_timestamp_ord. +--! @file v3/scalars/bigint/bigint_types.sql +--! @brief Encrypted-domain types for bigint. ---! @brief Index extractor for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_timestamp_ord) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +DO $$ +BEGIN + --! @brief Encrypted domain public.eql_v3_bigint. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'eql_v3_bigint' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.eql_v3_bigint AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b public.eql_v3_timestamp_ord + COMMENT ON DOMAIN public.eql_v3_bigint IS 'EQL encrypted bigint (storage only)'; + + --! @brief Encrypted domain public.eql_v3_bigint_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'eql_v3_bigint_eq' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.eql_v3_bigint_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'hm' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.eql_v3_bigint_eq IS 'EQL encrypted bigint (equality)'; + + --! @brief Encrypted domain public.eql_v3_bigint_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'eql_v3_bigint_ord_ore' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.eql_v3_bigint_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.eql_v3_bigint_ord_ore IS 'EQL encrypted bigint (equality, ordering)'; + + --! @brief Encrypted domain public.eql_v3_bigint_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'eql_v3_bigint_ord' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.eql_v3_bigint_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'op' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.eql_v3_bigint_ord IS 'EQL encrypted bigint (equality, ordering)'; + + --! @brief Encrypted domain public.eql_v3_bigint_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'eql_v3_bigint_ord_ope' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.eql_v3_bigint_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'op' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.eql_v3_bigint_ord_ope IS 'EQL encrypted bigint (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_functions.sql +--! @brief Functions for public.eql_v3_bigint. + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b public.eql_v3_bigint --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$; +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.eql_v3_bigint. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord +--! @param b public.eql_v3_bigint --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) = eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b public.eql_v3_bigint --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$; +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.eql_v3_bigint. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord +--! @param b public.eql_v3_bigint --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) <> eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b public.eql_v3_bigint --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.eql_v3_bigint. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord +--! @param b public.eql_v3_bigint --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) < eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b public.eql_v3_bigint --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.eql_v3_bigint. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord +--! @param b public.eql_v3_bigint --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) <= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b public.eql_v3_bigint --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.eql_v3_bigint. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord +--! @param b public.eql_v3_bigint --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) > eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b public.eql_v3_bigint --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.eql_v3_bigint. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord +--! @param b public.eql_v3_bigint --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) >= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b public.eql_v3_bigint --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.eql_v3_bigint. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord +--! @param b public.eql_v3_bigint --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b public.eql_v3_bigint --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.eql_v3_bigint. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord +--! @param b public.eql_v3_bigint --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param selector text ---! @return public.eql_v3_timestamp_ord -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord, selector text) -RETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$ +--! @return public.eql_v3_bigint +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint, selector text) +RETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param selector integer ---! @return public.eql_v3_timestamp_ord -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord, selector integer) -RETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$ +--! @return public.eql_v3_bigint +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint, selector integer) +RETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.eql_v3_bigint. --! @param a jsonb ---! @param selector public.eql_v3_timestamp_ord ---! @return public.eql_v3_timestamp_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_ord) -RETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$ +--! @param selector public.eql_v3_bigint +--! @return public.eql_v3_bigint +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint) +RETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.eql_v3_bigint. --! @param a jsonb ---! @param selector public.eql_v3_timestamp_ord +--! @param selector public.eql_v3_bigint --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_ord) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_ord, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b public.eql_v3_bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a jsonb +--! @param b public.eql_v3_bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b public.eql_v3_bigint --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint, b public.eql_v3_bigint) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.eql_v3_bigint. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord +--! @param b public.eql_v3_bigint --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_ord) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file v3/scalars/timestamp/query_timestamp_types.sql ---! @brief Query-operand domains for timestamp (index-terms-only, no ciphertext). ---! @note Query-operand domains live in `eql_v3` (not `public`): they are ---! never valid column types, so they don't belong in the column-type ---! namespace, and dropping the EQL-owned schema can never drop an ---! application column. ---! @note Cast a query operand explicitly to its `query_` domain in a predicate ---! (e.g. `WHERE col = $1::eql_v3.query_timestamp_eq`). A bare, ---! uncast literal RHS is ambiguous between the `query_` and `jsonb` ---! operator overloads and will not resolve. - -DO $$ -BEGIN - --! @brief Query-operand domain eql_v3.query_timestamp_eq (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_timestamp_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_timestamp_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'hm' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_timestamp_eq IS 'EQL timestamp query operand (equality)'; - - --! @brief Query-operand domain eql_v3.query_timestamp_ord_ore (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_timestamp_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_timestamp_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'ob' - AND NOT (VALUE ? 'c') - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_timestamp_ord_ore IS 'EQL timestamp query operand (equality, ordering)'; - - --! @brief Query-operand domain eql_v3.query_timestamp_ord (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_timestamp_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_timestamp_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'op' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_timestamp_ord IS 'EQL timestamp query operand (equality, ordering)'; - - --! @brief Query-operand domain eql_v3.query_timestamp_ord_ope (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_timestamp_ord_ope' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_timestamp_ord_ope AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'op' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_timestamp_ord_ope IS 'EQL timestamp query operand (equality, ordering)'; -END -$$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/timestamp_eq_functions.sql ---! @brief Functions for public.eql_v3_timestamp_eq. +--! @file encrypted_domain/bigint/bigint_ord_functions.sql +--! @brief Functions for public.eql_v3_bigint_ord. ---! @brief Index extractor for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_timestamp_eq) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_bigint_ord) +RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq +--! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_timestamp_eq) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_eq. +--! @brief Operator wrapper for public.eql_v3_bigint_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_eq +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_eq) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq +--! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_timestamp_eq) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_eq. +--! @brief Operator wrapper for public.eql_v3_bigint_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_eq +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_eq) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) <> eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq +--! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Operator wrapper for public.eql_v3_bigint_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_eq +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq +--! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Operator wrapper for public.eql_v3_bigint_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_eq +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq +--! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Operator wrapper for public.eql_v3_bigint_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_eq +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq +--! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Operator wrapper for public.eql_v3_bigint_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_eq +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_eq +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_eq) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_eq +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_eq) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param selector text ---! @return public.eql_v3_timestamp_eq -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_eq, selector text) -RETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$ +--! @return public.eql_v3_bigint_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord, selector text) +RETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param selector integer ---! @return public.eql_v3_timestamp_eq -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_eq, selector integer) -RETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$ +--! @return public.eql_v3_bigint_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord, selector integer) +RETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. --! @param a jsonb ---! @param selector public.eql_v3_timestamp_eq ---! @return public.eql_v3_timestamp_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_eq) -RETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$ +--! @param selector public.eql_v3_bigint_ord +--! @return public.eql_v3_bigint_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_ord) +RETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_eq, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_eq, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. --! @param a jsonb ---! @param selector public.eql_v3_timestamp_eq +--! @param selector public.eql_v3_bigint_ord --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_eq) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_ord) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_eq, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b public.eql_v3_bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a jsonb +--! @param b public.eql_v3_bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_bigint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_eq, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_eq, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_eq, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_eq, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_eq +--! @param b public.eql_v3_bigint_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_eq) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_search_ore_functions.sql ---! @brief Functions for public.eql_v3_text_search_ore. +--! @file v3/scalars/bigint/query_bigint_types.sql +--! @brief Query-operand domains for bigint (index-terms-only, no ciphertext). +--! @note Query-operand domains live in `eql_v3` (not `public`): they are +--! never valid column types, so they don't belong in the column-type +--! namespace, and dropping the EQL-owned schema can never drop an +--! application column. +--! @note Cast a query operand explicitly to its `query_` domain in a predicate +--! (e.g. `WHERE col = $1::eql_v3.query_bigint_eq`). A bare, +--! uncast literal RHS is ambiguous between the `query_` and `jsonb` +--! operator overloads and will not resolve. ---! @brief Index extractor for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_search_ore) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +DO $$ +BEGIN + --! @brief Query-operand domain eql_v3.query_bigint_eq (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_bigint_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_bigint_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Index extractor for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore + COMMENT ON DOMAIN eql_v3.query_bigint_eq IS 'EQL bigint query operand (equality)'; + + --! @brief Query-operand domain eql_v3.query_bigint_ord_ore (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_bigint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_bigint_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_bigint_ord_ore IS 'EQL bigint query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_bigint_ord (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_bigint_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_bigint_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_bigint_ord IS 'EQL bigint query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_bigint_ord_ope (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_bigint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_bigint_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_bigint_ord_ope IS 'EQL bigint query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ore_functions.sql +--! @brief Functions for public.eql_v3_bigint_ord_ore. + +--! @brief Index extractor for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_text_search_ore) +CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_bigint_ord_ore) RETURNS eql_v3_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; ---! @brief Index extractor for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @return eql_v3_internal.bloom_filter -CREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_search_ore) -RETURNS eql_v3_internal.bloom_filter -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; - ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_search_ore) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_text_search_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_search_ore) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search_ore) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_search_ore) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_text_search_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_search_ore) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search_ore) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) <> eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_text_search_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_search_ore) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) < eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_text_search_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_search_ore) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) <= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_text_search_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_search_ore) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) > eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_text_search_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_search_ore) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) >= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.contains(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contains(a public.eql_v3_text_search_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search_ore) $$; +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_text_search_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b public.eql_v3_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search_ore) @> eql_v3.match_term(b) $$; +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_search_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b::public.eql_v3_text_search_ore) $$; +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_text_search_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b public.eql_v3_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search_ore) <@ eql_v3.match_term(b) $$; - ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param selector text ---! @return public.eql_v3_text_search_ore -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search_ore, selector text) -RETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$ +--! @return public.eql_v3_bigint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ore, selector text) +RETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param selector integer ---! @return public.eql_v3_text_search_ore -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search_ore, selector integer) -RETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$ +--! @return public.eql_v3_bigint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ore, selector integer) +RETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. --! @param a jsonb ---! @param selector public.eql_v3_text_search_ore ---! @return public.eql_v3_text_search_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_search_ore) -RETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$ +--! @param selector public.eql_v3_bigint_ord_ore +--! @return public.eql_v3_bigint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_ord_ore) +RETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search_ore, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search_ore, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. --! @param a jsonb ---! @param selector public.eql_v3_text_search_ore +--! @param selector public.eql_v3_bigint_ord_ore --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_search_ore) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_search_ore, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_search_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_search_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_search_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_search_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_search_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_search_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search_ore, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search_ore, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search_ore, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_search_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search_ore, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_text_search_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_search_ore) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_search_functions.sql ---! @brief Functions for public.eql_v3_text_search. +--! @file encrypted_domain/bigint/bigint_ord_ore_operators.sql +--! @brief Operators for public.eql_v3_bigint_ord_ore. ---! @brief Index extractor for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_search) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Index extractor for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_search) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Index extractor for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @return eql_v3_internal.bloom_filter -CREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_search) -RETURNS eql_v3_internal.bloom_filter -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_search) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a jsonb ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search) = eql_v3.eq_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_search) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a jsonb ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_search) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a jsonb ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) < eql_v3.ord_term(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_search) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a jsonb ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_search) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a jsonb ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) > eql_v3.ord_term(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_search) $$; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a jsonb ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) >= eql_v3.ord_term(b) $$; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.contains(a public.eql_v3_text_search, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.contains(a public.eql_v3_text_search, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search) $$; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a jsonb ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search) @> eql_v3.match_term(b) $$; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_search, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_search, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b::public.eql_v3_text_search) $$; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a jsonb ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search) <@ eql_v3.match_term(b) $$; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param selector text ---! @return public.eql_v3_text_search -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search, selector text) -RETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param selector integer ---! @return public.eql_v3_text_search -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search, selector integer) -RETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a jsonb ---! @param selector public.eql_v3_text_search ---! @return public.eql_v3_text_search -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_search) -RETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a jsonb ---! @param selector public.eql_v3_text_search ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_search) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_search, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonpath +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_search, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_search, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_search, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_search, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonpath +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_search, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_search, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_search, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b public.eql_v3_text_search ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search, b public.eql_v3_text_search) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a jsonb ---! @param b public.eql_v3_text_search ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_search) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore +); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_ord_ore_functions.sql ---! @brief Functions for public.eql_v3_text_ord_ore. +--! @file encrypted_domain/bigint/bigint_ord_operators.sql +--! @brief Operators for public.eql_v3_bigint_ord. ---! @brief Index extractor for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord_ore) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Index extractor for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_text_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord_ore) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ore) = eql_v3.eq_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord_ore) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ore) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) < eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) <= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) > eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord +); ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) >= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param selector text ---! @return public.eql_v3_text_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ore, selector text) -RETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param selector integer ---! @return public.eql_v3_text_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ore, selector integer) -RETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_text_ord_ore ---! @return public.eql_v3_text_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_ord_ore) -RETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ore, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ore, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_text_ord_ore ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_ord_ore) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_ord_ore, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonpath +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonpath +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_ord_ore, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ore, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ore, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ore, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb +); ---! @file encrypted_domain/text/text_ord_ope_functions.sql ---! @brief Functions for public.eql_v3_text_ord_ope. +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Index extractor for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord_ope) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +--! @file encrypted_domain/bigint/query_bigint_ord_functions.sql +--! @brief Functions for eql_v3.query_bigint_ord. ---! @brief Index extractor for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope +--! @brief Index extractor for eql_v3.query_bigint_ord. +--! @param a eql_v3.query_bigint_ord --! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_ord_ope) +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_bigint_ord) RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b public.eql_v3_text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord_ope) $$; - ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ope +--! @brief Operator wrapper for eql_v3.query_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b eql_v3.query_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord_ope) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ope) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b public.eql_v3_text_ord_ope +--! @brief Operator wrapper for eql_v3.query_bigint_ord. +--! @param a eql_v3.query_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +CREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b eql_v3.query_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ope +--! @brief Operator wrapper for eql_v3.query_bigint_ord. +--! @param a eql_v3.query_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord_ope) +CREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ope) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b public.eql_v3_text_ord_ope +--! @brief Operator wrapper for eql_v3.query_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b eql_v3.query_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$; - ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ope +--! @brief Operator wrapper for eql_v3.query_bigint_ord. +--! @param a eql_v3.query_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord_ope) +CREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b public.eql_v3_text_ord_ope +--! @brief Operator wrapper for eql_v3.query_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b eql_v3.query_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$; - ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ope +--! @brief Operator wrapper for eql_v3.query_bigint_ord. +--! @param a eql_v3.query_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord_ope) +CREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b public.eql_v3_text_ord_ope +--! @brief Operator wrapper for eql_v3.query_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b eql_v3.query_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$; - ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ope +--! @brief Operator wrapper for eql_v3.query_bigint_ord. +--! @param a eql_v3.query_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord_ope) +CREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b public.eql_v3_text_ord_ope +--! @brief Operator wrapper for eql_v3.query_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b eql_v3.query_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_bigint_ord. +--! @param a eql_v3.query_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) >= eql_v3.ord_term(b) $$; +--! @file v3/scalars/real/query_real_types.sql +--! @brief Query-operand domains for real (index-terms-only, no ciphertext). +--! @note Query-operand domains live in `eql_v3` (not `public`): they are +--! never valid column types, so they don't belong in the column-type +--! namespace, and dropping the EQL-owned schema can never drop an +--! application column. +--! @note Cast a query operand explicitly to its `query_` domain in a predicate +--! (e.g. `WHERE col = $1::eql_v3.query_real_eq`). A bare, +--! uncast literal RHS is ambiguous between the `query_` and `jsonb` +--! operator overloads and will not resolve. ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b public.eql_v3_text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; +DO $$ +BEGIN + --! @brief Query-operand domain eql_v3.query_real_eq (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_real_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_real_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; + COMMENT ON DOMAIN eql_v3.query_real_eq IS 'EQL real query operand (equality)'; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b public.eql_v3_text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; + --! @brief Query-operand domain eql_v3.query_real_ord_ore (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_real_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_real_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; + COMMENT ON DOMAIN eql_v3.query_real_ord_ore IS 'EQL real query operand (equality, ordering)'; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param selector text ---! @return public.eql_v3_text_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ope, selector text) -RETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; + --! @brief Query-operand domain eql_v3.query_real_ord (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_real_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_real_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param selector integer ---! @return public.eql_v3_text_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ope, selector integer) -RETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; + COMMENT ON DOMAIN eql_v3.query_real_ord IS 'EQL real query operand (equality, ordering)'; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_text_ord_ope ---! @return public.eql_v3_text_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_ord_ope) -RETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; + --! @brief Query-operand domain eql_v3.query_real_ord_ope (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_real_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_real_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ope, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; + COMMENT ON DOMAIN eql_v3.query_real_ord_ope IS 'EQL real query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ope, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/real/query_real_ord_ore_functions.sql +--! @brief Functions for eql_v3.query_real_ord_ore. ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_text_ord_ope ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_ord_ope) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; +--! @brief Index extractor for eql_v3.query_real_ord_ore. +--! @param a eql_v3.query_real_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_real_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text +--! @brief Operator wrapper for eql_v3.query_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b eql_v3.query_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_ord_ope, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text[] +--! @brief Operator wrapper for eql_v3.query_real_ord_ore. +--! @param a eql_v3.query_real_ord_ore +--! @param b public.eql_v3_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text[] +--! @brief Operator wrapper for eql_v3.query_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b eql_v3.query_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonpath +--! @brief Operator wrapper for eql_v3.query_real_ord_ore. +--! @param a eql_v3.query_real_ord_ore +--! @param b public.eql_v3_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonpath +--! @brief Operator wrapper for eql_v3.query_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b eql_v3.query_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_ord_ope, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ope, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_real_ord_ore. +--! @param a eql_v3.query_real_ord_ore +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ope, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b eql_v3.query_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_real_ord_ore. +--! @param a eql_v3.query_real_ord_ore +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b eql_v3.query_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b public.eql_v3_text_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_real_ord_ore. +--! @param a eql_v3.query_real_ord_ore +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ope, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b eql_v3.query_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_real_ord_ore. +--! @param a eql_v3.query_real_ord_ore +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_ord_functions.sql ---! @brief Functions for public.eql_v3_text_ord. - ---! @brief Index extractor for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +--! @file encrypted_domain/real/real_ord_functions.sql +--! @brief Functions for public.eql_v3_real_ord. ---! @brief Index extractor for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Index extractor for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_ord) +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_real_ord) RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b public.eql_v3_text_ord +--! @brief Operator wrapper for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b public.eql_v3_text_ord) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Operator wrapper for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_real_ord) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. +--! @brief Operator wrapper for public.eql_v3_real_ord. --! @param a jsonb ---! @param b public.eql_v3_text_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b public.eql_v3_text_ord +--! @brief Operator wrapper for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b public.eql_v3_text_ord) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Operator wrapper for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_real_ord) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. +--! @brief Operator wrapper for public.eql_v3_real_ord. --! @param a jsonb ---! @param b public.eql_v3_text_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b public.eql_v3_text_ord +--! @brief Operator wrapper for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b public.eql_v3_text_ord) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Operator wrapper for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_real_ord) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. +--! @brief Operator wrapper for public.eql_v3_real_ord. --! @param a jsonb ---! @param b public.eql_v3_text_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b public.eql_v3_text_ord +--! @brief Operator wrapper for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b public.eql_v3_text_ord) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Operator wrapper for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_real_ord) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. +--! @brief Operator wrapper for public.eql_v3_real_ord. --! @param a jsonb ---! @param b public.eql_v3_text_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b public.eql_v3_text_ord +--! @brief Operator wrapper for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b public.eql_v3_text_ord) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Operator wrapper for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_real_ord) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. +--! @brief Operator wrapper for public.eql_v3_real_ord. --! @param a jsonb ---! @param b public.eql_v3_text_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b public.eql_v3_text_ord +--! @brief Operator wrapper for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b public.eql_v3_text_ord) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Operator wrapper for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_real_ord) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. +--! @brief Operator wrapper for public.eql_v3_real_ord. --! @param a jsonb ---! @param b public.eql_v3_text_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b public.eql_v3_text_ord) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. --! @param a jsonb ---! @param b public.eql_v3_text_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b public.eql_v3_text_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. --! @param a jsonb ---! @param b public.eql_v3_text_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param selector text ---! @return public.eql_v3_text_ord -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord, selector text) -RETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$ +--! @return public.eql_v3_real_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord, selector text) +RETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param selector integer ---! @return public.eql_v3_text_ord -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord, selector integer) -RETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$ +--! @return public.eql_v3_real_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord, selector integer) +RETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. --! @param a jsonb ---! @param selector public.eql_v3_text_ord ---! @return public.eql_v3_text_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_ord) -RETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$ +--! @param selector public.eql_v3_real_ord +--! @return public.eql_v3_real_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_ord) +RETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. --! @param a jsonb ---! @param selector public.eql_v3_text_ord +--! @param selector public.eql_v3_real_ord --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_ord) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_ord) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_ord, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b public.eql_v3_real_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord, b public.eql_v3_real_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a jsonb +--! @param b public.eql_v3_real_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_real_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b public.eql_v3_real_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord, b public.eql_v3_text_ord) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. --! @param a jsonb ---! @param b public.eql_v3_text_ord +--! @param b public.eql_v3_real_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_ord) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file v3/scalars/text/query_text_types.sql ---! @brief Query-operand domains for text (index-terms-only, no ciphertext). ---! @note Query-operand domains live in `eql_v3` (not `public`): they are ---! never valid column types, so they don't belong in the column-type ---! namespace, and dropping the EQL-owned schema can never drop an ---! application column. ---! @note Cast a query operand explicitly to its `query_` domain in a predicate ---! (e.g. `WHERE col = $1::eql_v3.query_text_eq`). A bare, ---! uncast literal RHS is ambiguous between the `query_` and `jsonb` ---! operator overloads and will not resolve. - -DO $$ -BEGIN - --! @brief Query-operand domain eql_v3.query_text_eq (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_text_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_text_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'hm' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_text_eq IS 'EQL text query operand (equality)'; - - --! @brief Query-operand domain eql_v3.query_text_match (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_text_match' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_text_match AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'bf' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_text_match IS 'EQL text query operand (containment)'; - - --! @brief Query-operand domain eql_v3.query_text_ord_ore (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_text_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_text_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'hm' - AND VALUE ? 'ob' - AND NOT (VALUE ? 'c') - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_text_ord_ore IS 'EQL text query operand (equality, ordering)'; - - --! @brief Query-operand domain eql_v3.query_text_ord (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_text_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_text_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'hm' - AND VALUE ? 'op' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_text_ord IS 'EQL text query operand (equality, ordering)'; - - --! @brief Query-operand domain eql_v3.query_text_ord_ope (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_text_ord_ope' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_text_ord_ope AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'hm' - AND VALUE ? 'op' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; +--! @file encrypted_domain/real/real_eq_functions.sql +--! @brief Functions for public.eql_v3_real_eq. - COMMENT ON DOMAIN eql_v3.query_text_ord_ope IS 'EQL text query operand (equality, ordering)'; +--! @brief Index extractor for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_real_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - --! @brief Query-operand domain eql_v3.query_text_search_ore (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_text_search_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_text_search_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'hm' - AND VALUE ? 'ob' - AND VALUE ? 'bf' - AND NOT (VALUE ? 'c') - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; +--! @brief Operator wrapper for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b public.eql_v3_real_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - COMMENT ON DOMAIN eql_v3.query_text_search_ore IS 'EQL text query operand (equality, ordering, containment)'; +--! @brief Operator wrapper for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_real_eq) $$; - --! @brief Query-operand domain eql_v3.query_text_search (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_text_search' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_text_search AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'hm' - AND VALUE ? 'op' - AND VALUE ? 'bf' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; +--! @brief Operator wrapper for public.eql_v3_real_eq. +--! @param a jsonb +--! @param b public.eql_v3_real_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) = eql_v3.eq_term(b) $$; - COMMENT ON DOMAIN eql_v3.query_text_search IS 'EQL text query operand (equality, ordering, containment)'; -END -$$; --- AUTOMATICALLY GENERATED FILE. +--! @brief Operator wrapper for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b public.eql_v3_real_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @file encrypted_domain/text/text_match_functions.sql ---! @brief Functions for public.eql_v3_text_match. +--! @brief Operator wrapper for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_real_eq) $$; ---! @brief Index extractor for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @return eql_v3_internal.bloom_filter -CREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_match) -RETURNS eql_v3_internal.bloom_filter -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; +--! @brief Operator wrapper for public.eql_v3_real_eq. +--! @param a jsonb +--! @param b public.eql_v3_real_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) <> eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b public.eql_v3_real_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b public.eql_v3_text_match) +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b jsonb) +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. --! @param a jsonb ---! @param b public.eql_v3_text_match +--! @param b public.eql_v3_real_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text_match) +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b public.eql_v3_real_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b public.eql_v3_text_match) +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b jsonb) +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. --! @param a jsonb ---! @param b public.eql_v3_text_match +--! @param b public.eql_v3_real_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text_match) +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b public.eql_v3_real_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b public.eql_v3_text_match) +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b jsonb) +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. --! @param a jsonb ---! @param b public.eql_v3_text_match +--! @param b public.eql_v3_real_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_match) +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b public.eql_v3_real_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b public.eql_v3_text_match) +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b jsonb) +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. --! @param a jsonb ---! @param b public.eql_v3_text_match +--! @param b public.eql_v3_real_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_match) +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b public.eql_v3_real_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b public.eql_v3_text_match) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. --! @param a jsonb ---! @param b public.eql_v3_text_match +--! @param b public.eql_v3_real_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_match) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b public.eql_v3_real_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b public.eql_v3_text_match) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. --! @param a jsonb ---! @param b public.eql_v3_text_match +--! @param b public.eql_v3_real_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_match) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match ---! @return boolean -CREATE FUNCTION eql_v3.contains(a public.eql_v3_text_match, b public.eql_v3_text_match) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; - ---! @brief Operator wrapper for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.contains(a public.eql_v3_text_match, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_match) $$; - ---! @brief Operator wrapper for public.eql_v3_text_match. ---! @param a jsonb ---! @param b public.eql_v3_text_match ---! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b public.eql_v3_text_match) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_match) @> eql_v3.match_term(b) $$; - ---! @brief Operator wrapper for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_match, b public.eql_v3_text_match) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; - ---! @brief Operator wrapper for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_match, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b::public.eql_v3_text_match) $$; - ---! @brief Operator wrapper for public.eql_v3_text_match. ---! @param a jsonb ---! @param b public.eql_v3_text_match ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b public.eql_v3_text_match) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_match) <@ eql_v3.match_term(b) $$; - ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param selector text ---! @return public.eql_v3_text_match -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_match, selector text) -RETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$ +--! @return public.eql_v3_real_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_eq, selector text) +RETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param selector integer ---! @return public.eql_v3_text_match -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_match, selector integer) -RETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$ +--! @return public.eql_v3_real_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_eq, selector integer) +RETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. --! @param a jsonb ---! @param selector public.eql_v3_text_match ---! @return public.eql_v3_text_match -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_match) -RETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$ +--! @param selector public.eql_v3_real_eq +--! @return public.eql_v3_real_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_eq) +RETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_match, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_match, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. --! @param a jsonb ---! @param selector public.eql_v3_text_match +--! @param selector public.eql_v3_real_eq --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_match) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_eq) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_match, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_match, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_match, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_match, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b public.eql_v3_real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a jsonb +--! @param b public.eql_v3_real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_match, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_match, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_match, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_match, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_match, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_match, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_match, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b public.eql_v3_real_eq --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_match, b public.eql_v3_text_match) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_match, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. --! @param a jsonb ---! @param b public.eql_v3_text_match +--! @param b public.eql_v3_real_eq --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_match) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_eq_functions.sql ---! @brief Functions for public.eql_v3_text_eq. +--! @file encrypted_domain/real/real_ord_ope_functions.sql +--! @brief Functions for public.eql_v3_real_ord_ope. ---! @brief Index extractor for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_eq) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_real_ord_ope) +RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b public.eql_v3_text_eq) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_eq) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_text_eq. +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text_eq +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_eq) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b public.eql_v3_text_eq) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_eq) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_text_eq. +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text_eq +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_eq) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) <> eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b public.eql_v3_text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text_eq +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b public.eql_v3_text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text_eq +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b public.eql_v3_text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text_eq +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b public.eql_v3_text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text_eq +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b public.eql_v3_text_eq) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text_eq +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_eq) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b public.eql_v3_text_eq) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text_eq +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_eq) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param selector text ---! @return public.eql_v3_text_eq -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_eq, selector text) -RETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$ +--! @return public.eql_v3_real_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ope, selector text) +RETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param selector integer ---! @return public.eql_v3_text_eq -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_eq, selector integer) -RETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$ +--! @return public.eql_v3_real_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ope, selector integer) +RETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. --! @param a jsonb ---! @param selector public.eql_v3_text_eq ---! @return public.eql_v3_text_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_eq) -RETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$ +--! @param selector public.eql_v3_real_ord_ope +--! @return public.eql_v3_real_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_ord_ope) +RETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_eq, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_eq, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. --! @param a jsonb ---! @param selector public.eql_v3_text_eq +--! @param selector public.eql_v3_real_ord_ope --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_eq) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_eq, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b public.eql_v3_real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_real_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_eq, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_eq, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_eq, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b public.eql_v3_real_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_eq, b public.eql_v3_text_eq) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_eq, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text_eq +--! @param b public.eql_v3_real_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_eq) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. +--! @file encrypted_domain/real/query_real_eq_functions.sql +--! @brief Functions for eql_v3.query_real_eq. + +--! @brief Index extractor for eql_v3.query_real_eq. +--! @param a eql_v3.query_real_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_real_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b eql_v3.query_real_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b eql_v3.query_real_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_real_eq. +--! @param a eql_v3.query_real_eq +--! @param b public.eql_v3_real_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_real_eq, b public.eql_v3_real_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b eql_v3.query_real_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b eql_v3.query_real_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_real_eq. +--! @param a eql_v3.query_real_eq +--! @param b public.eql_v3_real_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_real_eq, b public.eql_v3_real_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/query_real_ord_ope_functions.sql +--! @brief Functions for eql_v3.query_real_ord_ope. + +--! @brief Index extractor for eql_v3.query_real_ord_ope. +--! @param a eql_v3.query_real_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_real_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b eql_v3.query_real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_real_ord_ope. +--! @param a eql_v3.query_real_ord_ope +--! @param b public.eql_v3_real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b eql_v3.query_real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_real_ord_ope. +--! @param a eql_v3.query_real_ord_ope +--! @param b public.eql_v3_real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b eql_v3.query_real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_real_ord_ope. +--! @param a eql_v3.query_real_ord_ope +--! @param b public.eql_v3_real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b eql_v3.query_real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_real_ord_ope. +--! @param a eql_v3.query_real_ord_ope +--! @param b public.eql_v3_real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b eql_v3.query_real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_real_ord_ope. +--! @param a eql_v3.query_real_ord_ope +--! @param b public.eql_v3_real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b eql_v3.query_real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_real_ord_ope. +--! @param a eql_v3.query_real_ord_ope +--! @param b public.eql_v3_real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + --! @file encrypted_domain/smallint/smallint_ord_ore_functions.sql --! @brief Functions for public.eql_v3_smallint_ord_ore. @@ -6756,6 +7865,33 @@ RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore +--! @param b public.eql_v3_smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_smallint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. --! @param a public.eql_v3_smallint_ord_ore --! @param b jsonpath @@ -6847,56 +7983,403 @@ AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.e LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/smallint/smallint_ord_ope_functions.sql ---! @brief Functions for public.eql_v3_smallint_ord_ope. +--! @file encrypted_domain/smallint/smallint_ord_ore_operators.sql +--! @brief Operators for public.eql_v3_smallint_ord_ore. ---! @brief Index extractor for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_smallint_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) = eql_v3.ord_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/smallint/query_smallint_types.sql +--! @brief Query-operand domains for smallint (index-terms-only, no ciphertext). +--! @note Query-operand domains live in `eql_v3` (not `public`): they are +--! never valid column types, so they don't belong in the column-type +--! namespace, and dropping the EQL-owned schema can never drop an +--! application column. +--! @note Cast a query operand explicitly to its `query_` domain in a predicate +--! (e.g. `WHERE col = $1::eql_v3.query_smallint_eq`). A bare, +--! uncast literal RHS is ambiguous between the `query_` and `jsonb` +--! operator overloads and will not resolve. + +DO $$ +BEGIN + --! @brief Query-operand domain eql_v3.query_smallint_eq (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_smallint_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_smallint_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_smallint_eq IS 'EQL smallint query operand (equality)'; + + --! @brief Query-operand domain eql_v3.query_smallint_ord_ore (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_smallint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_smallint_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_smallint_ord_ore IS 'EQL smallint query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_smallint_ord (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_smallint_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_smallint_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_smallint_ord IS 'EQL smallint query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_smallint_ord_ope (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_smallint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_smallint_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_smallint_ord_ope IS 'EQL smallint query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ope_functions.sql +--! @brief Functions for public.eql_v3_smallint_ord_ope. + +--! @brief Index extractor for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_smallint_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b public.eql_v3_smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$; + +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b public.eql_v3_smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$; --! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. --! @param a jsonb @@ -7146,6 +8629,33 @@ RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b public.eql_v3_smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_smallint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. --! @param a public.eql_v3_smallint_ord_ope --! @param b jsonpath @@ -7536,6 +9046,33 @@ RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord +--! @param b public.eql_v3_smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @param a jsonb +--! @param b public.eql_v3_smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_smallint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$ +LANGUAGE plpgsql; + --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. --! @param a public.eql_v3_smallint_ord --! @param b jsonpath @@ -7627,3418 +9164,3749 @@ AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.e LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file v3/scalars/smallint/query_smallint_types.sql ---! @brief Query-operand domains for smallint (index-terms-only, no ciphertext). ---! @note Query-operand domains live in `eql_v3` (not `public`): they are ---! never valid column types, so they don't belong in the column-type ---! namespace, and dropping the EQL-owned schema can never drop an ---! application column. ---! @note Cast a query operand explicitly to its `query_` domain in a predicate ---! (e.g. `WHERE col = $1::eql_v3.query_smallint_eq`). A bare, ---! uncast literal RHS is ambiguous between the `query_` and `jsonb` ---! operator overloads and will not resolve. - -DO $$ -BEGIN - --! @brief Query-operand domain eql_v3.query_smallint_eq (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_smallint_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_smallint_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'hm' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_smallint_eq IS 'EQL smallint query operand (equality)'; - - --! @brief Query-operand domain eql_v3.query_smallint_ord_ore (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_smallint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_smallint_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'ob' - AND NOT (VALUE ? 'c') - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_smallint_ord_ore IS 'EQL smallint query operand (equality, ordering)'; - - --! @brief Query-operand domain eql_v3.query_smallint_ord (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_smallint_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_smallint_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'op' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_smallint_ord IS 'EQL smallint query operand (equality, ordering)'; - - --! @brief Query-operand domain eql_v3.query_smallint_ord_ope (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_smallint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_smallint_ord_ope AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'op' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_smallint_ord_ope IS 'EQL smallint query operand (equality, ordering)'; -END -$$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/smallint_eq_functions.sql ---! @brief Functions for public.eql_v3_smallint_eq. +--! @file encrypted_domain/smallint/query_smallint_eq_functions.sql +--! @brief Functions for eql_v3.query_smallint_eq. ---! @brief Index extractor for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Index extractor for eql_v3.query_smallint_eq. +--! @param a eql_v3.query_smallint_eq --! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_smallint_eq) RETURNS eql_v3_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_eq. +--! @brief Operator wrapper for eql_v3.query_smallint_eq. --! @param a public.eql_v3_smallint_eq +--! @param b eql_v3.query_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b eql_v3.query_smallint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_smallint_eq. +--! @param a eql_v3.query_smallint_eq --! @param b public.eql_v3_smallint_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_eq, b public.eql_v3_smallint_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_eq. +--! @brief Operator wrapper for eql_v3.query_smallint_eq. --! @param a public.eql_v3_smallint_eq ---! @param b jsonb +--! @param b eql_v3.query_smallint_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b eql_v3.query_smallint_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_smallint_eq) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_eq. ---! @param a jsonb +--! @brief Operator wrapper for eql_v3.query_smallint_eq. +--! @param a eql_v3.query_smallint_eq --! @param b public.eql_v3_smallint_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_eq, b public.eql_v3_smallint_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Operator wrapper for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq +--! @file encrypted_domain/smallint/query_smallint_ord_functions.sql +--! @brief Functions for eql_v3.query_smallint_ord. + +--! @brief Index extractor for eql_v3.query_smallint_ord. +--! @param a eql_v3.query_smallint_ord +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_smallint_ord) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_smallint_ord. +--! @param a public.eql_v3_smallint_ord +--! @param b eql_v3.query_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_smallint_ord. +--! @param a eql_v3.query_smallint_ord +--! @param b public.eql_v3_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b jsonb) +CREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_smallint_eq) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_eq. ---! @param a jsonb ---! @param b public.eql_v3_smallint_eq +--! @brief Operator wrapper for eql_v3.query_smallint_ord. +--! @param a public.eql_v3_smallint_ord +--! @param b eql_v3.query_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq +--! @brief Operator wrapper for eql_v3.query_smallint_ord. +--! @param a eql_v3.query_smallint_ord +--! @param b public.eql_v3_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_smallint_ord. +--! @param a public.eql_v3_smallint_ord +--! @param b eql_v3.query_smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_smallint_ord. +--! @param a eql_v3.query_smallint_ord +--! @param b public.eql_v3_smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_smallint_ord. +--! @param a public.eql_v3_smallint_ord +--! @param b eql_v3.query_smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_smallint_ord. +--! @param a eql_v3.query_smallint_ord +--! @param b public.eql_v3_smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_smallint_ord. +--! @param a public.eql_v3_smallint_ord +--! @param b eql_v3.query_smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_smallint_ord. +--! @param a eql_v3.query_smallint_ord +--! @param b public.eql_v3_smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_smallint_ord. +--! @param a public.eql_v3_smallint_ord +--! @param b eql_v3.query_smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_smallint_ord. +--! @param a eql_v3.query_smallint_ord +--! @param b public.eql_v3_smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_functions.sql +--! @brief Functions for public.eql_v3_smallint. + +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint +--! @param b public.eql_v3_smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_smallint. --! @param a jsonb ---! @param b public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_smallint. --! @param a jsonb ---! @param b public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_smallint. --! @param a jsonb ---! @param b public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_smallint. --! @param a jsonb ---! @param b public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_smallint. --! @param a jsonb ---! @param b public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_smallint. --! @param a jsonb ---! @param b public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint +--! @param b public.eql_v3_smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b public.eql_v3_smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a jsonb +--! @param b public.eql_v3_smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint +--! @param b public.eql_v3_smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b public.eql_v3_smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a jsonb +--! @param b public.eql_v3_smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param selector text ---! @return public.eql_v3_smallint_eq -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_eq, selector text) -RETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$ +--! @return public.eql_v3_smallint +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint, selector text) +RETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param selector integer ---! @return public.eql_v3_smallint_eq -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_eq, selector integer) -RETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$ +--! @return public.eql_v3_smallint +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint, selector integer) +RETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_smallint. --! @param a jsonb ---! @param selector public.eql_v3_smallint_eq ---! @return public.eql_v3_smallint_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint_eq) -RETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$ +--! @param selector public.eql_v3_smallint +--! @return public.eql_v3_smallint +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint) +RETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_eq, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_eq, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_smallint. --! @param a jsonb ---! @param selector public.eql_v3_smallint_eq +--! @param selector public.eql_v3_smallint --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint_eq, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint +--! @param b public.eql_v3_smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint, b public.eql_v3_smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a jsonb +--! @param b public.eql_v3_smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_eq, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_eq, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_eq, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint +--! @param b public.eql_v3_smallint --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_eq, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_smallint. --! @param a jsonb ---! @param b public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/real_ord_ore_functions.sql ---! @brief Functions for public.eql_v3_real_ord_ore. +--! @file encrypted_domain/smallint/smallint_ord_ope_operators.sql +--! @brief Operators for public.eql_v3_smallint_ord_ope. ---! @brief Index extractor for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_real_ord_ore) -RETURNS eql_v3_internal.ore_block_256 +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_functions.sql +--! @brief Functions for public.eql_v3_date_ord. + +--! @brief Index extractor for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_date_ord) +RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b public.eql_v3_real_ord_ore +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b public.eql_v3_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_date_ord) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @brief Operator wrapper for public.eql_v3_date_ord. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ore +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b public.eql_v3_real_ord_ore +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b public.eql_v3_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_date_ord) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @brief Operator wrapper for public.eql_v3_date_ord. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ore +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b public.eql_v3_real_ord_ore +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b public.eql_v3_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_date_ord) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @brief Operator wrapper for public.eql_v3_date_ord. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ore +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b public.eql_v3_real_ord_ore +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b public.eql_v3_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_date_ord) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @brief Operator wrapper for public.eql_v3_date_ord. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ore +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b public.eql_v3_real_ord_ore +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b public.eql_v3_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_date_ord) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @brief Operator wrapper for public.eql_v3_date_ord. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ore +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b public.eql_v3_real_ord_ore +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b public.eql_v3_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_date_ord) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @brief Operator wrapper for public.eql_v3_date_ord. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ore +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b public.eql_v3_date_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ore +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b public.eql_v3_date_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ore +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param selector text ---! @return public.eql_v3_real_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ore, selector text) -RETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$ +--! @return public.eql_v3_date_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord, selector text) +RETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param selector integer ---! @return public.eql_v3_real_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ore, selector integer) -RETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$ +--! @return public.eql_v3_date_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord, selector integer) +RETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. --! @param a jsonb ---! @param selector public.eql_v3_real_ord_ore ---! @return public.eql_v3_real_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_ord_ore) -RETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$ +--! @param selector public.eql_v3_date_ord +--! @return public.eql_v3_date_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_ord) +RETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ore, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ore, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. --! @param a jsonb ---! @param selector public.eql_v3_real_ord_ore +--! @param selector public.eql_v3_date_ord --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_ord) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b public.eql_v3_date_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord, b public.eql_v3_date_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a jsonb +--! @param b public.eql_v3_date_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_date_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ore, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b public.eql_v3_date_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord, b public.eql_v3_date_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ore +--! @param b public.eql_v3_date_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/real_ord_ope_functions.sql ---! @brief Functions for public.eql_v3_real_ord_ope. +--! @file v3/scalars/date/query_date_types.sql +--! @brief Query-operand domains for date (index-terms-only, no ciphertext). +--! @note Query-operand domains live in `eql_v3` (not `public`): they are +--! never valid column types, so they don't belong in the column-type +--! namespace, and dropping the EQL-owned schema can never drop an +--! application column. +--! @note Cast a query operand explicitly to its `query_` domain in a predicate +--! (e.g. `WHERE col = $1::eql_v3.query_date_eq`). A bare, +--! uncast literal RHS is ambiguous between the `query_` and `jsonb` +--! operator overloads and will not resolve. ---! @brief Index extractor for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +DO $$ +BEGIN + --! @brief Query-operand domain eql_v3.query_date_eq (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_date_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_date_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_date_eq IS 'EQL date query operand (equality)'; + + --! @brief Query-operand domain eql_v3.query_date_ord_ore (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_date_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_date_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_date_ord_ore IS 'EQL date query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_date_ord (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_date_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_date_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_date_ord IS 'EQL date query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_date_ord_ope (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_date_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_date_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_date_ord_ope IS 'EQL date query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/query_date_ord_functions.sql +--! @brief Functions for eql_v3.query_date_ord. + +--! @brief Index extractor for eql_v3.query_date_ord. +--! @param a eql_v3.query_date_ord --! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_date_ord) RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b public.eql_v3_real_ord_ope +--! @brief Operator wrapper for eql_v3.query_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b eql_v3.query_date_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b eql_v3.query_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_date_ord. +--! @param a eql_v3.query_date_ord +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord, b public.eql_v3_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_real_ord_ope +--! @brief Operator wrapper for eql_v3.query_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b eql_v3.query_date_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b eql_v3.query_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b public.eql_v3_real_ord_ope +--! @brief Operator wrapper for eql_v3.query_date_ord. +--! @param a eql_v3.query_date_ord +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord, b public.eql_v3_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b eql_v3.query_date_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b eql_v3.query_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_real_ord_ope +--! @brief Operator wrapper for eql_v3.query_date_ord. +--! @param a eql_v3.query_date_ord +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord, b public.eql_v3_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b public.eql_v3_real_ord_ope +--! @brief Operator wrapper for eql_v3.query_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b eql_v3.query_date_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b eql_v3.query_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_date_ord. +--! @param a eql_v3.query_date_ord +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord, b public.eql_v3_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_real_ord_ope +--! @brief Operator wrapper for eql_v3.query_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b eql_v3.query_date_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b eql_v3.query_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b public.eql_v3_real_ord_ope +--! @brief Operator wrapper for eql_v3.query_date_ord. +--! @param a eql_v3.query_date_ord +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord, b public.eql_v3_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b eql_v3.query_date_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b eql_v3.query_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_real_ord_ope +--! @brief Operator wrapper for eql_v3.query_date_ord. +--! @param a eql_v3.query_date_ord +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord, b public.eql_v3_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b public.eql_v3_real_ord_ope +--! @file encrypted_domain/date/date_ord_ore_functions.sql +--! @brief Functions for public.eql_v3_date_ord_ore. + +--! @brief Index extractor for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_date_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b public.eql_v3_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ope +--! @param b public.eql_v3_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b public.eql_v3_real_ord_ope +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b public.eql_v3_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ope +--! @param b public.eql_v3_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) <> eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b public.eql_v3_real_ord_ope +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b public.eql_v3_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$; + +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ope +--! @param b public.eql_v3_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) < eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b public.eql_v3_date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$; + +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) <= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b public.eql_v3_date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$; + +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) > eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b public.eql_v3_date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$; + +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) >= eql_v3.ord_term_ore(b) $$; + +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b public.eql_v3_date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b public.eql_v3_date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ope +--! @param b public.eql_v3_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param selector text ---! @return public.eql_v3_real_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ope, selector text) -RETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$ +--! @return public.eql_v3_date_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ore, selector text) +RETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param selector integer ---! @return public.eql_v3_real_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ope, selector integer) -RETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$ +--! @return public.eql_v3_date_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ore, selector integer) +RETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. --! @param a jsonb ---! @param selector public.eql_v3_real_ord_ope ---! @return public.eql_v3_real_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_ord_ope) -RETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$ +--! @param selector public.eql_v3_date_ord_ore +--! @return public.eql_v3_date_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_ord_ore) +RETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ope, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ope, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. --! @param a jsonb ---! @param selector public.eql_v3_real_ord_ope +--! @param selector public.eql_v3_date_ord_ore --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_ord_ope, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b public.eql_v3_date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_date_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ope, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ope, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b public.eql_v3_date_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ope +--! @param b public.eql_v3_date_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/real_ord_functions.sql ---! @brief Functions for public.eql_v3_real_ord. +--! @file encrypted_domain/date/date_ord_ope_functions.sql +--! @brief Functions for public.eql_v3_date_ord_ope. ---! @brief Index extractor for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Index extractor for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_date_ord_ope) RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b public.eql_v3_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_real_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real_ord +--! @param b public.eql_v3_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b public.eql_v3_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_real_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real_ord +--! @param b public.eql_v3_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b public.eql_v3_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_real_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real_ord +--! @param b public.eql_v3_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b public.eql_v3_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_real_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real_ord +--! @param b public.eql_v3_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b public.eql_v3_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_real_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real_ord +--! @param b public.eql_v3_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b public.eql_v3_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_real_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real_ord +--! @param b public.eql_v3_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b public.eql_v3_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real_ord +--! @param b public.eql_v3_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b public.eql_v3_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real_ord +--! @param b public.eql_v3_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param selector text ---! @return public.eql_v3_real_ord -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord, selector text) -RETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$ +--! @return public.eql_v3_date_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ope, selector text) +RETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param selector integer ---! @return public.eql_v3_real_ord -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord, selector integer) -RETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$ +--! @return public.eql_v3_date_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ope, selector integer) +RETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. --! @param a jsonb ---! @param selector public.eql_v3_real_ord ---! @return public.eql_v3_real_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_ord) -RETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$ +--! @param selector public.eql_v3_date_ord_ope +--! @return public.eql_v3_date_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_ord_ope) +RETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. --! @param a jsonb ---! @param selector public.eql_v3_real_ord +--! @param selector public.eql_v3_date_ord_ope --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_ord) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_ord, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b public.eql_v3_date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_date_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b public.eql_v3_date_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real_ord +--! @param b public.eql_v3_date_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file v3/scalars/real/query_real_types.sql ---! @brief Query-operand domains for real (index-terms-only, no ciphertext). ---! @note Query-operand domains live in `eql_v3` (not `public`): they are ---! never valid column types, so they don't belong in the column-type ---! namespace, and dropping the EQL-owned schema can never drop an ---! application column. ---! @note Cast a query operand explicitly to its `query_` domain in a predicate ---! (e.g. `WHERE col = $1::eql_v3.query_real_eq`). A bare, ---! uncast literal RHS is ambiguous between the `query_` and `jsonb` ---! operator overloads and will not resolve. - -DO $$ -BEGIN - --! @brief Query-operand domain eql_v3.query_real_eq (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_real_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_real_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'hm' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_real_eq IS 'EQL real query operand (equality)'; - - --! @brief Query-operand domain eql_v3.query_real_ord_ore (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_real_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_real_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'ob' - AND NOT (VALUE ? 'c') - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_real_ord_ore IS 'EQL real query operand (equality, ordering)'; - - --! @brief Query-operand domain eql_v3.query_real_ord (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_real_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_real_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'op' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_real_ord IS 'EQL real query operand (equality, ordering)'; - - --! @brief Query-operand domain eql_v3.query_real_ord_ope (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_real_ord_ope' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_real_ord_ope AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'op' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_real_ord_ope IS 'EQL real query operand (equality, ordering)'; -END -$$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/real/real_eq_functions.sql ---! @brief Functions for public.eql_v3_real_eq. +--! @file encrypted_domain/date/date_eq_functions.sql +--! @brief Functions for public.eql_v3_date_eq. ---! @brief Index extractor for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Index extractor for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_real_eq) +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_date_eq) RETURNS eql_v3_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq +--! @brief Operator wrapper for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b public.eql_v3_date_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Operator wrapper for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_real_eq) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_date_eq) $$; ---! @brief Operator wrapper for public.eql_v3_real_eq. +--! @brief Operator wrapper for public.eql_v3_date_eq. --! @param a jsonb ---! @param b public.eql_v3_real_eq +--! @param b public.eql_v3_date_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_eq) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq +--! @brief Operator wrapper for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b public.eql_v3_date_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Operator wrapper for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_real_eq) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_date_eq) $$; ---! @brief Operator wrapper for public.eql_v3_real_eq. +--! @brief Operator wrapper for public.eql_v3_date_eq. --! @param a jsonb ---! @param b public.eql_v3_real_eq +--! @param b public.eql_v3_date_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_eq) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) <> eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b public.eql_v3_date_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. --! @param a jsonb ---! @param b public.eql_v3_real_eq +--! @param b public.eql_v3_date_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real_eq) +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b public.eql_v3_date_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. --! @param a jsonb ---! @param b public.eql_v3_real_eq +--! @param b public.eql_v3_date_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real_eq) +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b public.eql_v3_date_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. --! @param a jsonb ---! @param b public.eql_v3_real_eq +--! @param b public.eql_v3_date_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real_eq) +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b public.eql_v3_date_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. --! @param a jsonb ---! @param b public.eql_v3_real_eq +--! @param b public.eql_v3_date_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real_eq) +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b public.eql_v3_date_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. --! @param a jsonb ---! @param b public.eql_v3_real_eq +--! @param b public.eql_v3_date_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_eq) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b public.eql_v3_date_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. --! @param a jsonb ---! @param b public.eql_v3_real_eq +--! @param b public.eql_v3_date_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_eq) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param selector text ---! @return public.eql_v3_real_eq -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_eq, selector text) -RETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$ +--! @return public.eql_v3_date_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_eq, selector text) +RETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param selector integer ---! @return public.eql_v3_real_eq -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_eq, selector integer) -RETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$ +--! @return public.eql_v3_date_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_eq, selector integer) +RETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. --! @param a jsonb ---! @param selector public.eql_v3_real_eq ---! @return public.eql_v3_real_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_eq) -RETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$ +--! @param selector public.eql_v3_date_eq +--! @return public.eql_v3_date_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_eq) +RETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_eq, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_eq, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. --! @param a jsonb ---! @param selector public.eql_v3_real_eq +--! @param selector public.eql_v3_date_eq --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_eq) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_eq) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_eq, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b public.eql_v3_date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_eq, b public.eql_v3_date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a jsonb +--! @param b public.eql_v3_date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_eq, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_eq, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_eq, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b public.eql_v3_date_eq --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_eq, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. --! @param a jsonb ---! @param b public.eql_v3_real_eq +--! @param b public.eql_v3_date_eq --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_eq) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file v3/scalars/numeric/query_numeric_types.sql ---! @brief Query-operand domains for numeric (index-terms-only, no ciphertext). ---! @note Query-operand domains live in `eql_v3` (not `public`): they are ---! never valid column types, so they don't belong in the column-type ---! namespace, and dropping the EQL-owned schema can never drop an ---! application column. ---! @note Cast a query operand explicitly to its `query_` domain in a predicate ---! (e.g. `WHERE col = $1::eql_v3.query_numeric_eq`). A bare, ---! uncast literal RHS is ambiguous between the `query_` and `jsonb` ---! operator overloads and will not resolve. - -DO $$ -BEGIN - --! @brief Query-operand domain eql_v3.query_numeric_eq (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_numeric_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_numeric_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'hm' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_numeric_eq IS 'EQL numeric query operand (equality)'; - - --! @brief Query-operand domain eql_v3.query_numeric_ord_ore (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_numeric_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_numeric_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'ob' - AND NOT (VALUE ? 'c') - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_numeric_ord_ore IS 'EQL numeric query operand (equality, ordering)'; - - --! @brief Query-operand domain eql_v3.query_numeric_ord (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_numeric_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_numeric_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'op' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_numeric_ord IS 'EQL numeric query operand (equality, ordering)'; - - --! @brief Query-operand domain eql_v3.query_numeric_ord_ope (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_numeric_ord_ope' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_numeric_ord_ope AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'op' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_numeric_ord_ope IS 'EQL numeric query operand (equality, ordering)'; -END -$$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_ord_ore_functions.sql ---! @brief Functions for public.eql_v3_numeric_ord_ore. - ---! @brief Index extractor for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_numeric_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +--! @file encrypted_domain/date/date_functions.sql +--! @brief Functions for public.eql_v3_date. ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b public.eql_v3_date --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$; +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_date. --! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_date --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) = eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b public.eql_v3_date --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$; +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_date. --! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_date --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) <> eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b public.eql_v3_date --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_date. --! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_date --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) < eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b public.eql_v3_date --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_date. --! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_date --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) <= eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b public.eql_v3_date --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_date. --! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_date --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) > eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b public.eql_v3_date --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_date. --! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_date --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) >= eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b public.eql_v3_date --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_date. --! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_date --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b public.eql_v3_date --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_date. --! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_date --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param selector text ---! @return public.eql_v3_numeric_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ore, selector text) -RETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$ +--! @return public.eql_v3_date +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date, selector text) +RETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param selector integer ---! @return public.eql_v3_numeric_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ore, selector integer) -RETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$ +--! @return public.eql_v3_date +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date, selector integer) +RETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_date. --! @param a jsonb ---! @param selector public.eql_v3_numeric_ord_ore ---! @return public.eql_v3_numeric_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric_ord_ore) -RETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$ +--! @param selector public.eql_v3_date +--! @return public.eql_v3_date +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date) +RETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ore, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ore, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_date. --! @param a jsonb ---! @param selector public.eql_v3_numeric_ord_ore +--! @param selector public.eql_v3_date --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric_ord_ore) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b public.eql_v3_date +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a jsonb +--! @param b public.eql_v3_date +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ore, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b public.eql_v3_date --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date, b public.eql_v3_date) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_date. --! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_date --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/numeric/numeric_ord_functions.sql ---! @brief Functions for public.eql_v3_numeric_ord. +--! @file encrypted_domain/date/date_ord_ore_operators.sql +--! @brief Operators for public.eql_v3_date_ord_ore. ---! @brief Index extractor for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_numeric_ord) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) = eql_v3.ord_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) <> eql_v3.ord_term(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) < eql_v3.ord_term(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) > eql_v3.ord_term(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) >= eql_v3.ord_term(b) $$; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param selector text ---! @return public.eql_v3_numeric_ord -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord, selector text) -RETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param selector integer ---! @return public.eql_v3_numeric_ord -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord, selector integer) -RETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param selector public.eql_v3_numeric_ord ---! @return public.eql_v3_numeric_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric_ord) -RETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param selector public.eql_v3_numeric_ord ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric_ord) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric_ord, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonpath +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric_ord, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonpath +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[] +); ---! @file encrypted_domain/numeric/numeric_ord_ope_functions.sql ---! @brief Functions for public.eql_v3_numeric_ord_ope. +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore +); ---! @brief Index extractor for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_numeric_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$; +--! @file encrypted_domain/date/date_ord_ope_operators.sql +--! @brief Operators for public.eql_v3_date_ord_ope. ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) = eql_v3.ord_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) <> eql_v3.ord_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) < eql_v3.ord_term(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) > eql_v3.ord_term(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) >= eql_v3.ord_term(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param selector text ---! @return public.eql_v3_numeric_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ope, selector text) -RETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param selector integer ---! @return public.eql_v3_numeric_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ope, selector integer) -RETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_numeric_ord_ope ---! @return public.eql_v3_numeric_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric_ord_ope) -RETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ope, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ope, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_numeric_ord_ope ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric_ord_ope) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric_ord_ope, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonpath +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric_ord_ope, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ope, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ope, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonpath +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ope, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/numeric/query_numeric_types.sql +--! @brief Query-operand domains for numeric (index-terms-only, no ciphertext). +--! @note Query-operand domains live in `eql_v3` (not `public`): they are +--! never valid column types, so they don't belong in the column-type +--! namespace, and dropping the EQL-owned schema can never drop an +--! application column. +--! @note Cast a query operand explicitly to its `query_` domain in a predicate +--! (e.g. `WHERE col = $1::eql_v3.query_numeric_eq`). A bare, +--! uncast literal RHS is ambiguous between the `query_` and `jsonb` +--! operator overloads and will not resolve. + +DO $$ +BEGIN + --! @brief Query-operand domain eql_v3.query_numeric_eq (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_numeric_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_numeric_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_numeric_eq IS 'EQL numeric query operand (equality)'; + + --! @brief Query-operand domain eql_v3.query_numeric_ord_ore (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_numeric_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_numeric_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_numeric_ord_ore IS 'EQL numeric query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_numeric_ord (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_numeric_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_numeric_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_numeric_ord IS 'EQL numeric query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_numeric_ord_ope (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_numeric_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_numeric_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_numeric_ord_ope IS 'EQL numeric query operand (equality, ordering)'; +END +$$; -- AUTOMATICALLY GENERATED FILE. --! @file encrypted_domain/numeric/numeric_eq_functions.sql @@ -11352,6 +13220,33 @@ RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq +--! @param b public.eql_v3_numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @param a jsonb +--! @param b public.eql_v3_numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$ +LANGUAGE plpgsql; + --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. --! @param a public.eql_v3_numeric_eq --! @param b jsonpath @@ -11443,2148 +13338,2637 @@ AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.e LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file v3/scalars/integer/query_integer_types.sql ---! @brief Query-operand domains for integer (index-terms-only, no ciphertext). ---! @note Query-operand domains live in `eql_v3` (not `public`): they are ---! never valid column types, so they don't belong in the column-type ---! namespace, and dropping the EQL-owned schema can never drop an ---! application column. ---! @note Cast a query operand explicitly to its `query_` domain in a predicate ---! (e.g. `WHERE col = $1::eql_v3.query_integer_eq`). A bare, ---! uncast literal RHS is ambiguous between the `query_` and `jsonb` ---! operator overloads and will not resolve. +--! @file encrypted_domain/numeric/numeric_ord_functions.sql +--! @brief Functions for public.eql_v3_numeric_ord. -DO $$ -BEGIN - --! @brief Query-operand domain eql_v3.query_integer_eq (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_integer_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_integer_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'hm' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; +--! @brief Index extractor for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_numeric_ord) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; - COMMENT ON DOMAIN eql_v3.query_integer_eq IS 'EQL integer query operand (equality)'; +--! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b public.eql_v3_numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - --! @brief Query-operand domain eql_v3.query_integer_ord_ore (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_integer_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_integer_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'ob' - AND NOT (VALUE ? 'c') - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_integer_ord_ore IS 'EQL integer query operand (equality, ordering)'; - - --! @brief Query-operand domain eql_v3.query_integer_ord (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_integer_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_integer_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'op' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_integer_ord IS 'EQL integer query operand (equality, ordering)'; - - --! @brief Query-operand domain eql_v3.query_integer_ord_ope (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_integer_ord_ope' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_integer_ord_ope AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'op' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_integer_ord_ope IS 'EQL integer query operand (equality, ordering)'; -END -$$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/integer/integer_ord_ore_functions.sql ---! @brief Functions for public.eql_v3_integer_ord_ore. - ---! @brief Index extractor for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_integer_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @brief Operator wrapper for public.eql_v3_numeric_ord. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @brief Operator wrapper for public.eql_v3_numeric_ord. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @brief Operator wrapper for public.eql_v3_numeric_ord. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @brief Operator wrapper for public.eql_v3_numeric_ord. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @brief Operator wrapper for public.eql_v3_numeric_ord. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @brief Operator wrapper for public.eql_v3_numeric_ord. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param selector text ---! @return public.eql_v3_integer_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ore, selector text) -RETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$ +--! @return public.eql_v3_numeric_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord, selector text) +RETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param selector integer ---! @return public.eql_v3_integer_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ore, selector integer) -RETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$ +--! @return public.eql_v3_numeric_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord, selector integer) +RETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. --! @param a jsonb ---! @param selector public.eql_v3_integer_ord_ore ---! @return public.eql_v3_integer_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_ord_ore) -RETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$ +--! @param selector public.eql_v3_numeric_ord +--! @return public.eql_v3_numeric_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric_ord) +RETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ore, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ore, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. --! @param a jsonb ---! @param selector public.eql_v3_integer_ord_ore +--! @param selector public.eql_v3_numeric_ord --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_ord_ore) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric_ord) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b public.eql_v3_numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a jsonb +--! @param b public.eql_v3_numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_numeric_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ore, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b public.eql_v3_numeric_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_numeric_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/integer/integer_ord_functions.sql ---! @brief Functions for public.eql_v3_integer_ord. +--! @file encrypted_domain/numeric/query_numeric_ord_functions.sql +--! @brief Functions for eql_v3.query_numeric_ord. ---! @brief Index extractor for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Index extractor for eql_v3.query_numeric_ord. +--! @param a eql_v3.query_numeric_ord --! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_numeric_ord) RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for eql_v3.query_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b eql_v3.query_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_numeric_ord. +--! @param a eql_v3.query_numeric_ord +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b jsonb) +CREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_integer_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a jsonb ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for eql_v3.query_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b eql_v3.query_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for eql_v3.query_numeric_ord. +--! @param a eql_v3.query_numeric_ord +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Operator wrapper for eql_v3.query_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b eql_v3.query_numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord. +--! @param a eql_v3.query_numeric_ord +--! @param b public.eql_v3_numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b eql_v3.query_numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord. +--! @param a eql_v3.query_numeric_ord +--! @param b public.eql_v3_numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b eql_v3.query_numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord. +--! @param a eql_v3.query_numeric_ord +--! @param b public.eql_v3_numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b eql_v3.query_numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord. +--! @param a eql_v3.query_numeric_ord +--! @param b public.eql_v3_numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ore_functions.sql +--! @brief Functions for public.eql_v3_numeric_ord_ore. + +--! @brief Index extractor for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_numeric_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_integer_ord) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_integer_ord +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_integer_ord) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_integer_ord +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) <> eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_integer_ord) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_integer_ord +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) < eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_integer_ord) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_integer_ord +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) <= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_integer_ord) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_integer_ord +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) > eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$; + +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) >= eql_v3.ord_term_ore(b) $$; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_integer_ord +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_integer_ord +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param selector text ---! @return public.eql_v3_integer_ord -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord, selector text) -RETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$ +--! @return public.eql_v3_numeric_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ore, selector text) +RETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param selector integer ---! @return public.eql_v3_integer_ord -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord, selector integer) -RETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$ +--! @return public.eql_v3_numeric_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ore, selector integer) +RETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. --! @param a jsonb ---! @param selector public.eql_v3_integer_ord ---! @return public.eql_v3_integer_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_ord) -RETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$ +--! @param selector public.eql_v3_numeric_ord_ore +--! @return public.eql_v3_numeric_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric_ord_ore) +RETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. --! @param a jsonb ---! @param selector public.eql_v3_integer_ord +--! @param selector public.eql_v3_numeric_ord_ore --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_ord, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_numeric_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_integer_ord +--! @param b public.eql_v3_numeric_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/integer/integer_ord_ope_functions.sql ---! @brief Functions for public.eql_v3_integer_ord_ope. +--! @file encrypted_domain/numeric/query_numeric_ord_ore_functions.sql +--! @brief Functions for eql_v3.query_numeric_ord_ore. ---! @brief Index extractor for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_integer_ord_ope) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for eql_v3.query_numeric_ord_ore. +--! @param a eql_v3.query_numeric_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_numeric_ord_ore) +RETURNS eql_v3_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b eql_v3.query_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. +--! @param a eql_v3.query_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b eql_v3.query_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. +--! @param a eql_v3.query_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b eql_v3.query_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. +--! @param a eql_v3.query_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b eql_v3.query_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. +--! @param a eql_v3.query_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b eql_v3.query_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. +--! @param a eql_v3.query_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b eql_v3.query_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. +--! @param a eql_v3.query_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ope_functions.sql +--! @brief Functions for public.eql_v3_numeric_ord_ope. + +--! @brief Index extractor for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_numeric_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$; + +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param selector text ---! @return public.eql_v3_integer_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ope, selector text) -RETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$ +--! @return public.eql_v3_numeric_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ope, selector text) +RETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param selector integer ---! @return public.eql_v3_integer_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ope, selector integer) -RETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$ +--! @return public.eql_v3_numeric_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ope, selector integer) +RETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. --! @param a jsonb ---! @param selector public.eql_v3_integer_ord_ope ---! @return public.eql_v3_integer_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_ord_ope) -RETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$ +--! @param selector public.eql_v3_numeric_ord_ope +--! @return public.eql_v3_numeric_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric_ord_ope) +RETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ope, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ope, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. --! @param a jsonb ---! @param selector public.eql_v3_integer_ord_ope +--! @param selector public.eql_v3_numeric_ord_ope --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_ord_ope, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_numeric_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ope, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ope, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/integer/integer_eq_functions.sql ---! @brief Functions for public.eql_v3_integer_eq. +--! @file encrypted_domain/numeric/query_numeric_ord_ope_functions.sql +--! @brief Functions for eql_v3.query_numeric_ord_ope. ---! @brief Index extractor for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_integer_eq) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for eql_v3.query_numeric_ord_ope. +--! @param a eql_v3.query_numeric_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_numeric_ord_ope) +RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b eql_v3.query_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. +--! @param a eql_v3.query_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b jsonb) +CREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_integer_eq) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b eql_v3.query_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_eq) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. +--! @param a eql_v3.query_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) +CREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b eql_v3.query_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_integer_eq) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. +--! @param a eql_v3.query_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_eq) +CREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b eql_v3.query_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. +--! @param a eql_v3.query_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b eql_v3.query_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. +--! @param a eql_v3.query_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b eql_v3.query_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. +--! @param a eql_v3.query_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/numeric/numeric_ord_ore_operators.sql +--! @brief Operators for public.eql_v3_numeric_ord_ore. ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param selector text ---! @return public.eql_v3_integer_eq -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_eq, selector text) -RETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param selector integer ---! @return public.eql_v3_integer_eq -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_eq, selector integer) -RETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param selector public.eql_v3_integer_eq ---! @return public.eql_v3_integer_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_eq) -RETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_eq, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_eq, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param selector public.eql_v3_integer_eq ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_eq) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_eq, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_eq, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_eq, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_eq, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_eq, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore +); -- AUTOMATICALLY GENERATED FILE. ---! @file v3/scalars/double/query_double_types.sql ---! @brief Query-operand domains for double (index-terms-only, no ciphertext). ---! @note Query-operand domains live in `eql_v3` (not `public`): they are ---! never valid column types, so they don't belong in the column-type ---! namespace, and dropping the EQL-owned schema can never drop an ---! application column. ---! @note Cast a query operand explicitly to its `query_` domain in a predicate ---! (e.g. `WHERE col = $1::eql_v3.query_double_eq`). A bare, ---! uncast literal RHS is ambiguous between the `query_` and `jsonb` ---! operator overloads and will not resolve. +--! @file encrypted_domain/numeric/numeric_ord_ope_operators.sql +--! @brief Operators for public.eql_v3_numeric_ord_ope. -DO $$ -BEGIN - --! @brief Query-operand domain eql_v3.query_double_eq (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_double_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_double_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'hm' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - COMMENT ON DOMAIN eql_v3.query_double_eq IS 'EQL double query operand (equality)'; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - --! @brief Query-operand domain eql_v3.query_double_ord_ore (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_double_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_double_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'ob' - AND NOT (VALUE ? 'c') - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - COMMENT ON DOMAIN eql_v3.query_double_ord_ore IS 'EQL double query operand (equality, ordering)'; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); - --! @brief Query-operand domain eql_v3.query_double_ord (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_double_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_double_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'op' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); - COMMENT ON DOMAIN eql_v3.query_double_ord IS 'EQL double query operand (equality, ordering)'; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); - --! @brief Query-operand domain eql_v3.query_double_ord_ope (term-only; no `c`). +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/json/json_types.sql +--! @brief Encrypted-domain types for json. + +DO $$ +BEGIN + --! @brief Encrypted domain public.eql_v3_json. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_double_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_json' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_double_ord_ope AS jsonb + CREATE DOMAIN public.eql_v3_json AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' - AND VALUE ? 'op' - AND NOT (VALUE ? 'c') + AND VALUE ? 'c' AND VALUE->>'v' = '3' ); END IF; - COMMENT ON DOMAIN eql_v3.query_double_ord_ope IS 'EQL double query operand (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_json IS 'EQL encrypted json (storage only)'; END $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/double_ord_ore_functions.sql ---! @brief Functions for public.eql_v3_double_ord_ore. - ---! @brief Index extractor for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_double_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +--! @file encrypted_domain/json/json_functions.sql +--! @brief Functions for public.eql_v3_json. ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b public.eql_v3_json --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$; +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_json. --! @param a jsonb ---! @param b public.eql_v3_double_ord_ore +--! @param b public.eql_v3_json --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) = eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b public.eql_v3_json --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$; +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_json. --! @param a jsonb ---! @param b public.eql_v3_double_ord_ore +--! @param b public.eql_v3_json --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) <> eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b public.eql_v3_json --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_json. --! @param a jsonb ---! @param b public.eql_v3_double_ord_ore +--! @param b public.eql_v3_json --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) < eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b public.eql_v3_json --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_json. --! @param a jsonb ---! @param b public.eql_v3_double_ord_ore +--! @param b public.eql_v3_json --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) <= eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b public.eql_v3_json --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_json. --! @param a jsonb ---! @param b public.eql_v3_double_ord_ore +--! @param b public.eql_v3_json --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) > eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b public.eql_v3_json --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_json. --! @param a jsonb ---! @param b public.eql_v3_double_ord_ore +--! @param b public.eql_v3_json --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) >= eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b public.eql_v3_json --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_json. --! @param a jsonb ---! @param b public.eql_v3_double_ord_ore +--! @param b public.eql_v3_json --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b public.eql_v3_json --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_json. --! @param a jsonb ---! @param b public.eql_v3_double_ord_ore +--! @param b public.eql_v3_json --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param selector text ---! @return public.eql_v3_double_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord_ore, selector text) -RETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$ +--! @return public.eql_v3_json +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_json, selector text) +RETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param selector integer ---! @return public.eql_v3_double_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord_ore, selector integer) -RETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$ +--! @return public.eql_v3_json +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_json, selector integer) +RETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_json. --! @param a jsonb ---! @param selector public.eql_v3_double_ord_ore ---! @return public.eql_v3_double_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double_ord_ore) -RETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$ +--! @param selector public.eql_v3_json +--! @return public.eql_v3_json +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_json) +RETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord_ore, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_json, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord_ore, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_json, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_json. --! @param a jsonb ---! @param selector public.eql_v3_double_ord_ore +--! @param selector public.eql_v3_json --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double_ord_ore) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_json) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_json, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_json, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_json, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_json, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b public.eql_v3_json +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_json, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_json, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a jsonb +--! @param b public.eql_v3_json +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_json, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_json, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_json, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_json, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ore, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_json, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_json, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_json, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b public.eql_v3_json --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_json, b public.eql_v3_json) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_json, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_json. --! @param a jsonb ---! @param b public.eql_v3_double_ord_ore +--! @param b public.eql_v3_json --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_json) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. +--! @file v3/scalars/double/query_double_types.sql +--! @brief Query-operand domains for double (index-terms-only, no ciphertext). +--! @note Query-operand domains live in `eql_v3` (not `public`): they are +--! never valid column types, so they don't belong in the column-type +--! namespace, and dropping the EQL-owned schema can never drop an +--! application column. +--! @note Cast a query operand explicitly to its `query_` domain in a predicate +--! (e.g. `WHERE col = $1::eql_v3.query_double_eq`). A bare, +--! uncast literal RHS is ambiguous between the `query_` and `jsonb` +--! operator overloads and will not resolve. + +DO $$ +BEGIN + --! @brief Query-operand domain eql_v3.query_double_eq (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_double_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_double_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_double_eq IS 'EQL double query operand (equality)'; + + --! @brief Query-operand domain eql_v3.query_double_ord_ore (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_double_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_double_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_double_ord_ore IS 'EQL double query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_double_ord (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_double_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_double_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_double_ord IS 'EQL double query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_double_ord_ope (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_double_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_double_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_double_ord_ope IS 'EQL double query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + --! @file encrypted_domain/double/double_ord_functions.sql --! @brief Functions for public.eql_v3_double_ord. @@ -13884,6 +16268,33 @@ RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; +--! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord, b public.eql_v3_double_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @param a jsonb +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_double_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$ +LANGUAGE plpgsql; + --! @brief Unsupported operator blocker for public.eql_v3_double_ord. --! @param a public.eql_v3_double_ord --! @param b jsonpath @@ -13975,6 +16386,423 @@ AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.e LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. +--! @file encrypted_domain/double/double_ord_ore_functions.sql +--! @brief Functions for public.eql_v3_double_ord_ore. + +--! @brief Index extractor for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_double_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$; + +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) = eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$; + +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) <> eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$; + +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) < eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$; + +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) <= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$; + +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) > eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$; + +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) >= eql_v3.ord_term_ore(b) $$; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param selector text +--! @return public.eql_v3_double_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord_ore, selector text) +RETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param selector integer +--! @return public.eql_v3_double_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord_ore, selector integer) +RETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a jsonb +--! @param selector public.eql_v3_double_ord_ore +--! @return public.eql_v3_double_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double_ord_ore) +RETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a jsonb +--! @param selector public.eql_v3_double_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_double_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_double_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + --! @file encrypted_domain/double/double_ord_ope_functions.sql --! @brief Functions for public.eql_v3_double_ord_ope. @@ -14274,6 +17102,33 @@ RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_double_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$ +LANGUAGE plpgsql; + --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. --! @param a public.eql_v3_double_ord_ope --! @param b jsonpath @@ -14365,15386 +17220,16679 @@ AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.e LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/double_eq_functions.sql ---! @brief Functions for public.eql_v3_double_eq. - ---! @brief Index extractor for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_double_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +--! @file encrypted_domain/double/double_ord_operators.sql +--! @brief Operators for public.eql_v3_double_ord. ---! @brief Operator wrapper for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b public.eql_v3_double_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_double_eq) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) = eql_v3.eq_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b public.eql_v3_double_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_double_eq) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b public.eql_v3_double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b public.eql_v3_double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b public.eql_v3_double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b public.eql_v3_double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b public.eql_v3_double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b public.eql_v3_double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param selector text ---! @return public.eql_v3_double_eq -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_eq, selector text) -RETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param selector integer ---! @return public.eql_v3_double_eq -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_eq, selector integer) -RETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param selector public.eql_v3_double_eq ---! @return public.eql_v3_double_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double_eq) -RETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_eq, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_eq, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param selector public.eql_v3_double_eq ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double_eq) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double_eq, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonpath +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double_eq, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_eq, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonpath +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_eq, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_eq, b public.eql_v3_double_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_eq, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[] +); ---! @file v3/scalars/date/query_date_types.sql ---! @brief Query-operand domains for date (index-terms-only, no ciphertext). ---! @note Query-operand domains live in `eql_v3` (not `public`): they are ---! never valid column types, so they don't belong in the column-type ---! namespace, and dropping the EQL-owned schema can never drop an ---! application column. ---! @note Cast a query operand explicitly to its `query_` domain in a predicate ---! (e.g. `WHERE col = $1::eql_v3.query_date_eq`). A bare, ---! uncast literal RHS is ambiguous between the `query_` and `jsonb` ---! operator overloads and will not resolve. +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord +); -DO $$ -BEGIN - --! @brief Query-operand domain eql_v3.query_date_eq (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_date_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_date_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'hm' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb +); - COMMENT ON DOMAIN eql_v3.query_date_eq IS 'EQL date query operand (equality)'; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord +); +-- AUTOMATICALLY GENERATED FILE. - --! @brief Query-operand domain eql_v3.query_date_ord_ore (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_date_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_date_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'ob' - AND NOT (VALUE ? 'c') - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; +--! @file encrypted_domain/double/double_ord_ope_operators.sql +--! @brief Operators for public.eql_v3_double_ord_ope. - COMMENT ON DOMAIN eql_v3.query_date_ord_ore IS 'EQL date query operand (equality, ordering)'; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - --! @brief Query-operand domain eql_v3.query_date_ord (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_date_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_date_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'op' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - COMMENT ON DOMAIN eql_v3.query_date_ord IS 'EQL date query operand (equality, ordering)'; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - --! @brief Query-operand domain eql_v3.query_date_ord_ope (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_date_ord_ope' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_date_ord_ope AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'op' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); - COMMENT ON DOMAIN eql_v3.query_date_ord_ope IS 'EQL date query operand (equality, ordering)'; -END -$$; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @file encrypted_domain/date/date_ord_ore_functions.sql ---! @brief Functions for public.eql_v3_date_ord_ore. +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Index extractor for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_date_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b public.eql_v3_date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) = eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b public.eql_v3_date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) <> eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b public.eql_v3_date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) < eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b public.eql_v3_date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) <= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope +); ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b public.eql_v3_date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb +); ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope +); ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) > eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope +); ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b public.eql_v3_date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb +); ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope +); ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) >= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b public.eql_v3_date_ord_ore +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_functions.sql +--! @brief Functions for public.eql_v3_double. + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b public.eql_v3_double --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_double. --! @param a jsonb ---! @param b public.eql_v3_date_ord_ore +--! @param b public.eql_v3_double --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ore) +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b public.eql_v3_double --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_double. --! @param a jsonb ---! @param b public.eql_v3_date_ord_ore +--! @param b public.eql_v3_double --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ore) +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param selector text ---! @return public.eql_v3_date_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ore, selector text) -RETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$ +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a jsonb +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a jsonb +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a jsonb +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a jsonb +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a jsonb +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a jsonb +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param selector text +--! @return public.eql_v3_double +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double, selector text) +RETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double --! @param selector integer ---! @return public.eql_v3_date_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ore, selector integer) -RETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$ +--! @return public.eql_v3_double +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double, selector integer) +RETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_double. --! @param a jsonb ---! @param selector public.eql_v3_date_ord_ore ---! @return public.eql_v3_date_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_ord_ore) -RETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$ +--! @param selector public.eql_v3_double +--! @return public.eql_v3_double +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double) +RETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ore, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ore, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_double. --! @param a jsonb ---! @param selector public.eql_v3_date_ord_ore +--! @param selector public.eql_v3_double --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_ord_ore) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a jsonb +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ore, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b public.eql_v3_double --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double, b public.eql_v3_double) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_double. --! @param a jsonb ---! @param b public.eql_v3_date_ord_ore +--! @param b public.eql_v3_double --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/date_ord_functions.sql ---! @brief Functions for public.eql_v3_date_ord. +--! @file encrypted_domain/double/query_double_eq_functions.sql +--! @brief Functions for eql_v3.query_double_eq. ---! @brief Index extractor for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_date_ord) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for eql_v3.query_double_eq. +--! @param a eql_v3.query_double_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_double_eq) +RETURNS eql_v3_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b public.eql_v3_date_ord +--! @brief Operator wrapper for eql_v3.query_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b eql_v3.query_double_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b public.eql_v3_date_ord) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b eql_v3.query_double_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_double_eq. +--! @param a eql_v3.query_double_eq +--! @param b public.eql_v3_double_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b jsonb) +CREATE FUNCTION eql_v3.eq(a eql_v3.query_double_eq, b public.eql_v3_double_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_date_ord) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a jsonb ---! @param b public.eql_v3_date_ord +--! @brief Operator wrapper for eql_v3.query_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b eql_v3.query_double_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b eql_v3.query_double_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b public.eql_v3_date_ord +--! @brief Operator wrapper for eql_v3.query_double_eq. +--! @param a eql_v3.query_double_eq +--! @param b public.eql_v3_double_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b public.eql_v3_date_ord) +CREATE FUNCTION eql_v3.neq(a eql_v3.query_double_eq, b public.eql_v3_double_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_date_ord) $$; +--! @file encrypted_domain/double/double_ord_ore_operators.sql +--! @brief Operators for public.eql_v3_double_ord_ore. ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a jsonb ---! @param b public.eql_v3_date_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) <> eql_v3.ord_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b public.eql_v3_date_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b public.eql_v3_date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_date_ord) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a jsonb ---! @param b public.eql_v3_date_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) < eql_v3.ord_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b public.eql_v3_date_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b public.eql_v3_date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_date_ord) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a jsonb ---! @param b public.eql_v3_date_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b public.eql_v3_date_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b public.eql_v3_date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_eq_functions.sql +--! @brief Functions for public.eql_v3_integer_eq. + +--! @brief Index extractor for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_integer_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b public.eql_v3_integer_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_date_ord) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_integer_eq) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord. +--! @brief Operator wrapper for public.eql_v3_integer_eq. --! @param a jsonb ---! @param b public.eql_v3_date_ord +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b public.eql_v3_date_ord +--! @brief Operator wrapper for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b public.eql_v3_date_ord) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord +--! @brief Operator wrapper for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_date_ord) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_integer_eq) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord. +--! @brief Operator wrapper for public.eql_v3_integer_eq. --! @param a jsonb ---! @param b public.eql_v3_date_ord +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) <> eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b public.eql_v3_date_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b public.eql_v3_date_ord) +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. --! @param a jsonb ---! @param b public.eql_v3_date_ord +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord) +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b public.eql_v3_date_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b public.eql_v3_date_ord) +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. --! @param a jsonb ---! @param b public.eql_v3_date_ord +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord) +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param selector text ---! @return public.eql_v3_date_ord -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord, selector text) -RETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$ +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b public.eql_v3_integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param selector integer ---! @return public.eql_v3_date_ord -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord, selector integer) -RETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$ +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. --! @param a jsonb ---! @param selector public.eql_v3_date_ord ---! @return public.eql_v3_date_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_ord) -RETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$ +--! @param b public.eql_v3_integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$ +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b public.eql_v3_integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$ +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. --! @param a jsonb ---! @param selector public.eql_v3_date_ord ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_ord) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$ +--! @param b public.eql_v3_integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b text +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_ord, b text) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b text[] +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_ord, b text[]) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b text[] +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a jsonb +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_ord, b text[]) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b jsonpath +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b jsonpath +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord'; END; $$ +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a jsonb +--! @param b public.eql_v3_integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_ord, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord'; END; $$ +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param selector text +--! @return public.eql_v3_integer_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_eq, selector text) +RETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$ +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param selector integer +--! @return public.eql_v3_integer_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_eq, selector integer) +RETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$ +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a jsonb +--! @param selector public.eql_v3_integer_eq +--! @return public.eql_v3_integer_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_eq) +RETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a jsonb +--! @param selector public.eql_v3_integer_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b public.eql_v3_integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a jsonb +--! @param b public.eql_v3_integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_ord, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b public.eql_v3_date_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord, b public.eql_v3_date_ord) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b public.eql_v3_integer_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. --! @param a jsonb ---! @param b public.eql_v3_date_ord +--! @param b public.eql_v3_integer_eq --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_ord) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/date_ord_ope_functions.sql ---! @brief Functions for public.eql_v3_date_ord_ope. +--! @file encrypted_domain/integer/integer_ord_functions.sql +--! @brief Functions for public.eql_v3_integer_ord. ---! @brief Index extractor for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Index extractor for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_integer_ord) RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b public.eql_v3_date_ord_ope +--! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_integer_ord) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @brief Operator wrapper for public.eql_v3_integer_ord. --! @param a jsonb ---! @param b public.eql_v3_date_ord_ope +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b public.eql_v3_date_ord_ope +--! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_integer_ord) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @brief Operator wrapper for public.eql_v3_integer_ord. --! @param a jsonb ---! @param b public.eql_v3_date_ord_ope +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b public.eql_v3_date_ord_ope +--! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_integer_ord) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @brief Operator wrapper for public.eql_v3_integer_ord. --! @param a jsonb ---! @param b public.eql_v3_date_ord_ope +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b public.eql_v3_date_ord_ope +--! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_integer_ord) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @brief Operator wrapper for public.eql_v3_integer_ord. --! @param a jsonb ---! @param b public.eql_v3_date_ord_ope +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b public.eql_v3_date_ord_ope +--! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_integer_ord) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @brief Operator wrapper for public.eql_v3_integer_ord. --! @param a jsonb ---! @param b public.eql_v3_date_ord_ope +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b public.eql_v3_date_ord_ope +--! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_integer_ord) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @brief Operator wrapper for public.eql_v3_integer_ord. --! @param a jsonb ---! @param b public.eql_v3_date_ord_ope +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. --! @param a jsonb ---! @param b public.eql_v3_date_ord_ope +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. --! @param a jsonb ---! @param b public.eql_v3_date_ord_ope +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param selector text ---! @return public.eql_v3_date_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ope, selector text) -RETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$ +--! @return public.eql_v3_integer_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord, selector text) +RETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param selector integer ---! @return public.eql_v3_date_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ope, selector integer) -RETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$ +--! @return public.eql_v3_integer_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord, selector integer) +RETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. --! @param a jsonb ---! @param selector public.eql_v3_date_ord_ope ---! @return public.eql_v3_date_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_ord_ope) -RETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$ +--! @param selector public.eql_v3_integer_ord +--! @return public.eql_v3_integer_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_ord) +RETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ope, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ope, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. --! @param a jsonb ---! @param selector public.eql_v3_date_ord_ope +--! @param selector public.eql_v3_integer_ord --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_ord) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_ord_ope, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b public.eql_v3_integer_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a jsonb +--! @param b public.eql_v3_integer_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_integer_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ope, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ope, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b public.eql_v3_integer_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. --! @param a jsonb ---! @param b public.eql_v3_date_ord_ope +--! @param b public.eql_v3_integer_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/date_eq_functions.sql ---! @brief Functions for public.eql_v3_date_eq. +--! @file encrypted_domain/integer/integer_ord_operators.sql +--! @brief Operators for public.eql_v3_integer_ord. ---! @brief Index extractor for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_date_eq) -RETURNS eql_v3_internal.hmac_256 +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ore_functions.sql +--! @brief Functions for public.eql_v3_integer_ord_ore. + +--! @brief Index extractor for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_integer_ord_ore) +RETURNS eql_v3_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b public.eql_v3_date_eq) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_date_eq) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_date_eq. +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_date_eq +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_eq) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b public.eql_v3_date_eq) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_date_eq) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_date_eq. +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_date_eq +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_eq) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) <> eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b public.eql_v3_date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_date_eq +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) < eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b public.eql_v3_date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_date_eq +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) <= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b public.eql_v3_date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_date_eq +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) > eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b public.eql_v3_date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_date_eq +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) >= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b public.eql_v3_date_eq) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_date_eq +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_eq) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b public.eql_v3_date_eq) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_date_eq +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_eq) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param selector text ---! @return public.eql_v3_date_eq -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_eq, selector text) -RETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$ +--! @return public.eql_v3_integer_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ore, selector text) +RETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param selector integer ---! @return public.eql_v3_date_eq -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_eq, selector integer) -RETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$ +--! @return public.eql_v3_integer_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ore, selector integer) +RETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. --! @param a jsonb ---! @param selector public.eql_v3_date_eq ---! @return public.eql_v3_date_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_eq) -RETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$ +--! @param selector public.eql_v3_integer_ord_ore +--! @return public.eql_v3_integer_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_ord_ore) +RETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_eq, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_eq, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. --! @param a jsonb ---! @param selector public.eql_v3_date_eq +--! @param selector public.eql_v3_integer_ord_ore --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_eq) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_eq, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_integer_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_eq, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_eq, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_eq, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_eq, b public.eql_v3_date_eq) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_eq, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_date_eq +--! @param b public.eql_v3_integer_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_eq) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file v3/scalars/boolean/boolean_types.sql ---! @brief Encrypted-domain types for boolean. +--! @file encrypted_domain/integer/integer_ord_ore_operators.sql +--! @brief Operators for public.eql_v3_integer_ord_ore. -DO $$ -BEGIN - --! @brief Encrypted domain public.eql_v3_boolean. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_boolean' AND typnamespace = 'public'::regnamespace - ) THEN - CREATE DOMAIN public.eql_v3_boolean AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE->>'v' = '3' - ); - END IF; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - COMMENT ON DOMAIN public.eql_v3_boolean IS 'EQL encrypted boolean (storage only)'; -END -$$; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @file v3/scalars/bigint/query_bigint_types.sql ---! @brief Query-operand domains for bigint (index-terms-only, no ciphertext). ---! @note Query-operand domains live in `eql_v3` (not `public`): they are ---! never valid column types, so they don't belong in the column-type ---! namespace, and dropping the EQL-owned schema can never drop an ---! application column. ---! @note Cast a query operand explicitly to its `query_` domain in a predicate ---! (e.g. `WHERE col = $1::eql_v3.query_bigint_eq`). A bare, ---! uncast literal RHS is ambiguous between the `query_` and `jsonb` ---! operator overloads and will not resolve. +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); -DO $$ -BEGIN - --! @brief Query-operand domain eql_v3.query_bigint_eq (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_bigint_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_bigint_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'hm' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); - COMMENT ON DOMAIN eql_v3.query_bigint_eq IS 'EQL bigint query operand (equality)'; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); - --! @brief Query-operand domain eql_v3.query_bigint_ord_ore (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_bigint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_bigint_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'ob' - AND NOT (VALUE ? 'c') - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); - COMMENT ON DOMAIN eql_v3.query_bigint_ord_ore IS 'EQL bigint query operand (equality, ordering)'; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); - --! @brief Query-operand domain eql_v3.query_bigint_ord (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_bigint_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_bigint_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'op' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); - COMMENT ON DOMAIN eql_v3.query_bigint_ord IS 'EQL bigint query operand (equality, ordering)'; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); - --! @brief Query-operand domain eql_v3.query_bigint_ord_ope (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_bigint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_bigint_ord_ope AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'op' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); - COMMENT ON DOMAIN eql_v3.query_bigint_ord_ope IS 'EQL bigint query operand (equality, ordering)'; -END -$$; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @file encrypted_domain/bigint/bigint_ord_ore_functions.sql ---! @brief Functions for public.eql_v3_bigint_ord_ore. +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Index extractor for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_bigint_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) = eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord_ore) +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/integer/query_integer_types.sql +--! @brief Query-operand domains for integer (index-terms-only, no ciphertext). +--! @note Query-operand domains live in `eql_v3` (not `public`): they are +--! never valid column types, so they don't belong in the column-type +--! namespace, and dropping the EQL-owned schema can never drop an +--! application column. +--! @note Cast a query operand explicitly to its `query_` domain in a predicate +--! (e.g. `WHERE col = $1::eql_v3.query_integer_eq`). A bare, +--! uncast literal RHS is ambiguous between the `query_` and `jsonb` +--! operator overloads and will not resolve. + +DO $$ +BEGIN + --! @brief Query-operand domain eql_v3.query_integer_eq (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_integer_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_integer_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_integer_eq IS 'EQL integer query operand (equality)'; + + --! @brief Query-operand domain eql_v3.query_integer_ord_ore (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_integer_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_integer_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_integer_ord_ore IS 'EQL integer query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_integer_ord (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_integer_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_integer_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_integer_ord IS 'EQL integer query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_integer_ord_ope (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_integer_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_integer_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_integer_ord_ope IS 'EQL integer query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ope_functions.sql +--! @brief Functions for public.eql_v3_integer_ord_ope. + +--! @brief Index extractor for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_integer_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$; + +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param selector text ---! @return public.eql_v3_bigint_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ore, selector text) -RETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$ +--! @return public.eql_v3_integer_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ope, selector text) +RETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param selector integer ---! @return public.eql_v3_bigint_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ore, selector integer) -RETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$ +--! @return public.eql_v3_integer_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ope, selector integer) +RETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. --! @param a jsonb ---! @param selector public.eql_v3_bigint_ord_ore ---! @return public.eql_v3_bigint_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_ord_ore) -RETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$ +--! @param selector public.eql_v3_integer_ord_ope +--! @return public.eql_v3_integer_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_ord_ope) +RETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ore, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ore, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. --! @param a jsonb ---! @param selector public.eql_v3_bigint_ord_ore +--! @param selector public.eql_v3_integer_ord_ope --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_ord_ore) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_integer_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ore, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_integer_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/bigint/bigint_ord_functions.sql ---! @brief Functions for public.eql_v3_bigint_ord. - ---! @brief Index extractor for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_bigint_ord) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +--! @file encrypted_domain/integer/integer_functions.sql +--! @brief Functions for public.eql_v3_integer. ---! @brief Operator wrapper for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b public.eql_v3_integer --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$; +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord +--! @param b public.eql_v3_integer --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) = eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b public.eql_v3_integer --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$; +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord +--! @param b public.eql_v3_integer --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) <> eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b public.eql_v3_integer --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord +--! @param b public.eql_v3_integer --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) < eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b public.eql_v3_integer --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord +--! @param b public.eql_v3_integer --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) <= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b public.eql_v3_integer --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord +--! @param b public.eql_v3_integer --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) > eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b public.eql_v3_integer --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord +--! @param b public.eql_v3_integer --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) >= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b public.eql_v3_integer --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord +--! @param b public.eql_v3_integer --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b public.eql_v3_integer --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord +--! @param b public.eql_v3_integer --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param selector text ---! @return public.eql_v3_bigint_ord -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord, selector text) -RETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$ +--! @return public.eql_v3_integer +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer, selector text) +RETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param selector integer ---! @return public.eql_v3_bigint_ord -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord, selector integer) -RETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$ +--! @return public.eql_v3_integer +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer, selector integer) +RETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer. --! @param a jsonb ---! @param selector public.eql_v3_bigint_ord ---! @return public.eql_v3_bigint_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_ord) -RETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$ +--! @param selector public.eql_v3_integer +--! @return public.eql_v3_integer +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer) +RETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer. --! @param a jsonb ---! @param selector public.eql_v3_bigint_ord +--! @param selector public.eql_v3_integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_ord) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_ord, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b jsonpath +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b public.eql_v3_integer --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a jsonb +--! @param b public.eql_v3_integer +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b public.eql_v3_integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord +--! @param b public.eql_v3_integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_ord) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/bigint/bigint_ord_ope_functions.sql ---! @brief Functions for public.eql_v3_bigint_ord_ope. +--! @file encrypted_domain/integer/query_integer_eq_functions.sql +--! @brief Functions for eql_v3.query_integer_eq. ---! @brief Index extractor for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_bigint_ord_ope) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for eql_v3.query_integer_eq. +--! @param a eql_v3.query_integer_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_integer_eq) +RETURNS eql_v3_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope +--! @brief Operator wrapper for eql_v3.query_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b eql_v3.query_integer_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b eql_v3.query_integer_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_integer_eq. +--! @param a eql_v3.query_integer_eq +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ope +--! @brief Operator wrapper for eql_v3.query_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b eql_v3.query_integer_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord_ope) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b eql_v3.query_integer_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope +--! @brief Operator wrapper for eql_v3.query_integer_eq. +--! @param a eql_v3.query_integer_eq +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +CREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$; +--! @file v3/sem/ore_block_256/operator_class.sql +--! @brief B-tree operator family + default class on eql_v3_internal.ore_block_256. +--! +--! Gives the composite type its DEFAULT btree opclass so the recommended +--! functional index `CREATE INDEX ON t (eql_v3.ord_term_ore(col))` engages without +--! an explicit opclass annotation (design D4). +--! +--! @note Creating an operator family/class requires superuser: Postgres forbids +--! CREATE OPERATOR FAMILY / CLASS to non-superusers to protect index +--! integrity. Managed platforms (Supabase, and most hosted Postgres) run +--! the installer as a non-superuser role, so the DO block below ATTEMPTS +--! the creation and skips it on insufficient_privilege (SQLSTATE 42501), +--! letting the single installer run everywhere. When the class is absent, +--! ORE ordered scans over eql_v3_internal.ore_block_256 are unavailable, +--! but the order-preserving (OPE) ordering domains — whose extractor +--! return types carry a native btree opclass — still index without it. On +--! superuser installs (self-managed Postgres, the SQLx test matrix) the +--! class is created normally. Any non-privilege error still propagates. +--! @see eql_v3_internal.compare_ore_block_256_terms ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) <> eql_v3.ord_term(b) $$; +DO $do$ +BEGIN + EXECUTE 'CREATE OPERATOR FAMILY eql_v3_internal.ore_block_256_operator_family USING btree'; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + EXECUTE $ddl$ + CREATE OPERATOR CLASS eql_v3_internal.ore_block_256_operator_class + DEFAULT FOR TYPE eql_v3_internal.ore_block_256 + USING btree FAMILY eql_v3_internal.ore_block_256_operator_family AS + OPERATOR 1 public.<, + OPERATOR 2 public.<=, + OPERATOR 3 public.=, + OPERATOR 4 public.>=, + OPERATOR 5 public.>, + FUNCTION 1 eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) + $ddl$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$; + RAISE NOTICE 'EQL: created btree operator class eql_v3_internal.ore_block_256_operator_class'; +EXCEPTION + WHEN insufficient_privilege THEN + 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'; +END; +$do$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) < eql_v3.ord_term(b) $$; +--! @file v3/scalars/timestamp/query_timestamp_types.sql +--! @brief Query-operand domains for timestamp (index-terms-only, no ciphertext). +--! @note Query-operand domains live in `eql_v3` (not `public`): they are +--! never valid column types, so they don't belong in the column-type +--! namespace, and dropping the EQL-owned schema can never drop an +--! application column. +--! @note Cast a query operand explicitly to its `query_` domain in a predicate +--! (e.g. `WHERE col = $1::eql_v3.query_timestamp_eq`). A bare, +--! uncast literal RHS is ambiguous between the `query_` and `jsonb` +--! operator overloads and will not resolve. ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +DO $$ +BEGIN + --! @brief Query-operand domain eql_v3.query_timestamp_eq (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_timestamp_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_timestamp_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$; + COMMENT ON DOMAIN eql_v3.query_timestamp_eq IS 'EQL timestamp query operand (equality)'; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) <= eql_v3.ord_term(b) $$; + --! @brief Query-operand domain eql_v3.query_timestamp_ord_ore (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_timestamp_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_timestamp_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + COMMENT ON DOMAIN eql_v3.query_timestamp_ord_ore IS 'EQL timestamp query operand (equality, ordering)'; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$; + --! @brief Query-operand domain eql_v3.query_timestamp_ord (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_timestamp_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_timestamp_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) > eql_v3.ord_term(b) $$; + COMMENT ON DOMAIN eql_v3.query_timestamp_ord IS 'EQL timestamp query operand (equality, ordering)'; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + --! @brief Query-operand domain eql_v3.query_timestamp_ord_ope (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_timestamp_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_timestamp_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$; + COMMENT ON DOMAIN eql_v3.query_timestamp_ord_ope IS 'EQL timestamp query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) >= eql_v3.ord_term(b) $$; +--! @file v3/scalars/text/query_text_types.sql +--! @brief Query-operand domains for text (index-terms-only, no ciphertext). +--! @note Query-operand domains live in `eql_v3` (not `public`): they are +--! never valid column types, so they don't belong in the column-type +--! namespace, and dropping the EQL-owned schema can never drop an +--! application column. +--! @note Cast a query operand explicitly to its `query_` domain in a predicate +--! (e.g. `WHERE col = $1::eql_v3.query_text_eq`). A bare, +--! uncast literal RHS is ambiguous between the `query_` and `jsonb` +--! operator overloads and will not resolve. ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; +DO $$ +BEGIN + --! @brief Query-operand domain eql_v3.query_text_eq (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_text_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_text_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; + COMMENT ON DOMAIN eql_v3.query_text_eq IS 'EQL text query operand (equality)'; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; + --! @brief Query-operand domain eql_v3.query_text_match (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_text_match' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_text_match AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'bf' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; + COMMENT ON DOMAIN eql_v3.query_text_match IS 'EQL text query operand (matching)'; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; + --! @brief Query-operand domain eql_v3.query_text_ord_ore (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_text_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_text_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; + COMMENT ON DOMAIN eql_v3.query_text_ord_ore IS 'EQL text query operand (equality, ordering)'; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param selector text ---! @return public.eql_v3_bigint_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ope, selector text) -RETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; + --! @brief Query-operand domain eql_v3.query_text_ord (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_text_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_text_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param selector integer ---! @return public.eql_v3_bigint_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ope, selector integer) -RETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; + COMMENT ON DOMAIN eql_v3.query_text_ord IS 'EQL text query operand (equality, ordering)'; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_bigint_ord_ope ---! @return public.eql_v3_bigint_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_ord_ope) -RETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; + --! @brief Query-operand domain eql_v3.query_text_ord_ope (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_text_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_text_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ope, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; + COMMENT ON DOMAIN eql_v3.query_text_ord_ope IS 'EQL text query operand (equality, ordering)'; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ope, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; + --! @brief Query-operand domain eql_v3.query_text_search_ore (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_text_search_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_text_search_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND VALUE ? 'ob' + AND VALUE ? 'bf' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_bigint_ord_ope ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_ord_ope) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; + COMMENT ON DOMAIN eql_v3.query_text_search_ore IS 'EQL text query operand (equality, ordering, matching)'; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_ord_ope, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; + --! @brief Query-operand domain eql_v3.query_text_search (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_text_search' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_text_search AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND VALUE ? 'op' + AND VALUE ? 'bf' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text[] + COMMENT ON DOMAIN eql_v3.query_text_search IS 'EQL text query operand (equality, ordering, matching)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_match_functions.sql +--! @brief Functions for public.eql_v3_text_match. + +--! @brief Index extractor for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @return eql_v3_internal.bloom_filter +CREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_match) +RETURNS eql_v3_internal.bloom_filter +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; + +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text[] +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonpath +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a jsonb +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonpath +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_ord_ope, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ope, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ope, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ope, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_eq_functions.sql ---! @brief Functions for public.eql_v3_bigint_eq. - ---! @brief Index extractor for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_bigint_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Operator wrapper for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_bigint_eq) $$; - ---! @brief Operator wrapper for public.eql_v3_bigint_eq. ---! @param a jsonb ---! @param b public.eql_v3_bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_bigint_eq) $$; +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_text_match. --! @param a jsonb ---! @param b public.eql_v3_bigint_eq +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) <> eql_v3.eq_term(b) $$; +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$ +LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_text_match. --! @param a jsonb ---! @param b public.eql_v3_bigint_eq +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint_eq) +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_text_match. --! @param a jsonb ---! @param b public.eql_v3_bigint_eq +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint_eq) +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_text_match. --! @param a jsonb ---! @param b public.eql_v3_bigint_eq +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint_eq) +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_text_match. --! @param a jsonb ---! @param b public.eql_v3_bigint_eq +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint_eq) +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_text_match. --! @param a jsonb ---! @param b public.eql_v3_bigint_eq +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_eq) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_text_match. --! @param a jsonb ---! @param b public.eql_v3_bigint_eq +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_eq) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param selector text ---! @return public.eql_v3_bigint_eq -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_eq, selector text) -RETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$ +--! @return public.eql_v3_text_match +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_match, selector text) +RETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param selector integer ---! @return public.eql_v3_bigint_eq -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_eq, selector integer) -RETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$ +--! @return public.eql_v3_text_match +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_match, selector integer) +RETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_text_match. --! @param a jsonb ---! @param selector public.eql_v3_bigint_eq ---! @return public.eql_v3_bigint_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_eq) -RETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$ +--! @param selector public.eql_v3_text_match +--! @return public.eql_v3_text_match +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_match) +RETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_eq, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_match, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_eq, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_match, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_text_match. --! @param a jsonb ---! @param selector public.eql_v3_bigint_eq +--! @param selector public.eql_v3_text_match --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_eq) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_match) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_eq, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_match, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_match, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_match, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_match, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Operator wrapper for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @param b public.eql_v3_text_match +--! @return boolean +CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b public.eql_v3_text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_match) $$; + +--! @brief Operator wrapper for public.eql_v3_text_match. +--! @param a jsonb +--! @param b public.eql_v3_text_match +--! @return boolean +CREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_match) @> eql_v3.match_term(b) $$; + +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_match, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_match, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_match, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_eq, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_match, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_eq, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_match, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_eq, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_match, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_match, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @param b public.eql_v3_text_match --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_eq, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_match, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_text_match. --! @param a jsonb ---! @param b public.eql_v3_bigint_eq +--! @param b public.eql_v3_text_match --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_eq) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_match) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. ---! @file v3/jsonb/types.sql ---! @brief Domain types for the eql_v3 encrypted-JSONB (SteVec) surface. ---! ---! Three jsonb-backed domains (none over another domain — operators resolve ---! against the ultimate base type jsonb, so the native-jsonb firewall in ---! blockers.sql can attach): ---! - public.eql_v3_json — storage/root: an EQL envelope object ({i, v, ...}). ---! - public.eql_v3_jsonb_entry — a single sv element (returned by `->`). ---! - eql_v3.query_jsonb — a containment needle (sv elements, no ciphertext). - ---! @brief Validate a single SteVec entry payload. ---! @internal ---! @param val jsonb Candidate entry payload. ---! @return boolean True when `val` is an sv entry with string `s`, string `c`, ---! and exactly one string deterministic term (`hm` XOR `op`). -CREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_entry_payload(val jsonb) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT COALESCE( - jsonb_typeof(val) = 'object' - AND jsonb_typeof(val -> 's') = 'string' - AND jsonb_typeof(val -> 'c') = 'string' - AND ( - (jsonb_typeof(val -> 'hm') = 'string' AND NOT (val ? 'op')) - OR - (jsonb_typeof(val -> 'op') = 'string' AND NOT (val ? 'hm')) - ), - false - ) -$$; +--! @file encrypted_domain/text/text_ord_ope_functions.sql +--! @brief Functions for public.eql_v3_text_ord_ope. ---! @brief Validate a SteVec containment query payload. ---! @internal ---! @param val jsonb Candidate query payload. ---! @return boolean True when `val` is `{"sv":[...]}` and every element carries ---! string `s`, no ciphertext, and exactly one string term (`hm` XOR ---! `op`). ---! @note plpgsql, not LANGUAGE sql (issues #353/#354): the only caller is the ---! eql_v3.query_jsonb domain CHECK, where a SQL function can never be ---! inlined (and the CHECK itself cannot absorb this body — it needs a ---! subquery over the sv elements, which CHECK constraints forbid). plpgsql ---! caches its plan across calls instead of paying the per-call SQL-function ---! executor on every needle cast. -CREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_query_payload(val jsonb) - RETURNS boolean - LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -AS $$ -BEGIN - RETURN COALESCE( - jsonb_typeof(val) = 'object' - AND jsonb_typeof(val -> 'sv') = 'array' - AND NOT EXISTS ( - SELECT 1 - FROM jsonb_array_elements( - CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END - ) AS elem - WHERE NOT COALESCE(( - jsonb_typeof(elem) = 'object' - AND jsonb_typeof(elem -> 's') = 'string' - AND NOT (elem ? 'c') - AND ( - (jsonb_typeof(elem -> 'hm') = 'string' AND NOT (elem ? 'op')) - OR - (jsonb_typeof(elem -> 'op') = 'string' AND NOT (elem ? 'hm')) - ) - ), false) - ), - false - ); -END; -$$; +--! @brief Index extractor for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord_ope) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Validate a root SteVec document payload. ---! @internal ---! @param val jsonb Candidate document payload. ---! @return boolean True when `val` is an encrypted document envelope with ---! `v = 3`, `i`, an `sv` array, and valid sv entry elements. -CREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_document_payload(val jsonb) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT COALESCE( - jsonb_typeof(val) = 'object' - AND val ? 'v' - AND val ->> 'v' = '3' - AND val ? 'i' - AND jsonb_typeof(val -> 'sv') = 'array' - AND NOT EXISTS ( - SELECT 1 - FROM jsonb_array_elements( - CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END - ) AS elem - WHERE NOT public.eql_v3_is_valid_ste_vec_entry_payload(elem) - ), - false - ) -$$; +--! @brief Index extractor for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Storage/root domain for an encrypted JSONB column. ---! ---! CHECK: a JSON object carrying the EQL envelope (`v = 3` version and `i` index ---! metadata). Root `c` is intentionally NOT required — an sv-array root payload ---! is `{i, v, sv}` with no root ciphertext. The CHECK now also requires an `sv` ---! array, so the domain accepts only SteVec **document** payloads and rejects ---! encrypted *scalar* payloads (which carry `c`/`hm`/`ob` but no `sv`) — this is ---! what keeps `public.eql_v3_json` a typed document domain rather than a generic ---! encrypted envelope. The firewall in blockers.sql attaches to this domain to ---! stop native jsonb operators from reaching a column value. ---! ---! @note Constructing from inline JSON uses the standard DOMAIN cast: ---! `'{"i":{},"v":3,"sv":[...]}'::public.eql_v3_json`. -DO $$ -BEGIN - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_json' AND typnamespace = 'public'::regnamespace - ) THEN - CREATE DOMAIN public.eql_v3_json AS jsonb - CHECK ( - public.eql_v3_is_valid_ste_vec_document_payload(VALUE) - ); - END IF; +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - COMMENT ON DOMAIN public.eql_v3_json IS 'EQL encrypted JSONB document (containment, equality, ordering)'; -END -$$; +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord_ope) $$; ---! @brief Domain type for an individual sv element. ---! ---! A single element inside an `sv` array: a JSON object that carries a selector ---! (`s`), a ciphertext (`c`), and **exactly one** of `hm` (HMAC-256, for ---! hash-equality) or `op` (CLLW OPE, for ordered queries) — they are mutually ---! exclusive. This is the type returned by `->` and accepted by the per-entry ---! extractors `eql_v3.eq_term` / `eql_v3.ord_term`. Extra fields (`a`, root ---! `i`/`v` merged in by `->`) are allowed. ---! ---! @see src/v3/jsonb/operators.sql ---! ---! @internal ---! Implementation note (issue #354): the CHECK is an INLINE expression, not a ---! call to `public.eql_v3_is_valid_ste_vec_entry_payload` — domain ---! constraints cannot inline SQL functions, so the function-call form paid ---! the per-call SQL-function executor (~18 µs) on EVERY cast: the needle ---! cast in every field_eq query (+19% end-to-end vs v2, the entire measured ---! regression on that scenario; see cipherstash/benches#23). The expression ---! mirrors the validator body; the leading `VALUE IS NULL OR` preserves the ---! validator's STRICT NULL-passes semantics (a bare COALESCE(..., false) ---! would reject NULL, which `->` returns for a missing selector). Keep the ---! two in sync — `jsonb_entry_check_matches_validator` in tests/sqlx pins ---! the equivalence. ---! @endinternal -DO $$ -BEGIN - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_jsonb_entry' AND typnamespace = 'public'::regnamespace - ) THEN - CREATE DOMAIN public.eql_v3_jsonb_entry AS jsonb - CHECK ( - VALUE IS NULL - OR COALESCE( - jsonb_typeof(VALUE) = 'object' - AND jsonb_typeof(VALUE -> 's') = 'string' - AND jsonb_typeof(VALUE -> 'c') = 'string' - AND ( - (jsonb_typeof(VALUE -> 'hm') = 'string' AND NOT (VALUE ? 'op')) - OR - (jsonb_typeof(VALUE -> 'op') = 'string' AND NOT (VALUE ? 'hm')) - ), - false - ) - ); - END IF; +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ope) = eql_v3.eq_term(b) $$; - COMMENT ON DOMAIN public.eql_v3_jsonb_entry IS 'EQL encrypted JSONB leaf entry (equality, ordering)'; -END -$$; +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Domain type for an STE-vec containment needle. ---! ---! A query-shaped payload `{"sv":[...]}` whose elements carry selector + index ---! term but **never** a ciphertext (`c`). Each element must carry `s` and ---! exactly one deterministic term (`hm` XOR `op`). Typing the needle this way ---! stops selector-only needles from casting and matching every row via bare ---! `jsonb @>`. ---! ---! @note Construct from inline JSON via the DOMAIN cast: ---! `'{"sv":[{"s":"","hm":""}]}'::eql_v3.query_jsonb`. ---! @see eql_v3.to_ste_vec_query ---! ---! @internal ---! Implementation note (issue #354): this CHECK CANNOT be inlined like ---! public.eql_v3_jsonb_entry's — validating the sv elements requires a subquery ---! (`NOT EXISTS (SELECT ... FROM jsonb_array_elements(...))`), and CHECK ---! constraints forbid subqueries. The validator is plpgsql instead (cached ---! plan; substantially cheaper per call than a non-inlined LANGUAGE sql ---! function — the same finding as issue #353), since this cast sits on the ---! per-query hot path of every containment scenario ---! (`$1::jsonb::eql_v3.query_jsonb`). ---! @endinternal -DO $$ -BEGIN - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_jsonb' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_jsonb AS jsonb - CHECK ( - public.eql_v3_is_valid_ste_vec_query_payload(VALUE) - ); - END IF; +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord_ope) $$; - COMMENT ON DOMAIN eql_v3.query_jsonb IS 'EQL JSONB query operand (containment)'; -END -$$; +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ope) <> eql_v3.eq_term(b) $$; ---! @brief Convert a public.eql_v3_json to a query_jsonb needle. ---! ---! Normalises each sv element down to the matching-relevant fields: `s` plus ---! exactly one of `hm` / `op`. Other fields (`c`, `a`, `i`/`v`, anything else) ---! are stripped. This is the canonical needle shape for `@>` containment. ---! Designed for use as a functional GIN index expression: ---! `GIN (eql_v3.to_ste_vec_query(col)::jsonb jsonb_path_ops)`. ---! ---! @param e public.eql_v3_json Source encrypted payload ---! @return eql_v3.query_jsonb Query-shaped needle, sv elements normalised. ---! @see eql_v3.query_jsonb -CREATE FUNCTION eql_v3.to_ste_vec_query(e public.eql_v3_json) - RETURNS eql_v3.query_jsonb - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT jsonb_build_object( - 'sv', - coalesce( - (SELECT jsonb_agg( - jsonb_strip_nulls( - jsonb_build_object( - 's', elem -> 's', - 'hm', elem -> 'hm', - 'op', elem -> 'op' - ) - ) - ) - FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem), - '[]'::jsonb - ) - )::eql_v3.query_jsonb -$$; +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE CAST (public.eql_v3_json AS eql_v3.query_jsonb) - WITH FUNCTION eql_v3.to_ste_vec_query - AS ASSIGNMENT; --- AUTOMATICALLY GENERATED FILE. +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$; ---! @file encrypted_domain/timestamp/timestamp_ord_ore_operators.sql ---! @brief Operators for public.eql_v3_timestamp_ord_ore. +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) < eql_v3.ord_term(b) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) > eql_v3.ord_term(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) >= eql_v3.ord_term(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param selector text +--! @return public.eql_v3_text_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ope, selector text) +RETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param selector integer +--! @return public.eql_v3_text_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ope, selector integer) +RETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a jsonb +--! @param selector public.eql_v3_text_ord_ope +--! @return public.eql_v3_text_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_ord_ope) +RETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a jsonb +--! @param selector public.eql_v3_text_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_text_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b public.eql_v3_text_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer -); +--! @file encrypted_domain/text/query_text_ord_functions.sql +--! @brief Functions for eql_v3.query_text_ord. -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[] -); +--! @brief Index extractor for eql_v3.query_text_ord. +--! @param a eql_v3.query_text_ord +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[] -); +--! @brief Index extractor for eql_v3.query_text_ord. +--! @param a eql_v3.query_text_ord +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_ord) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore -); +--! @brief Operator wrapper for eql_v3.query_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b eql_v3.query_text_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b eql_v3.query_text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb -); +--! @brief Operator wrapper for eql_v3.query_text_ord. +--! @param a eql_v3.query_text_ord +--! @param b public.eql_v3_text_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord, b public.eql_v3_text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Operator wrapper for eql_v3.query_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b eql_v3.query_text_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b eql_v3.query_text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @file encrypted_domain/timestamp/timestamp_ord_ope_operators.sql ---! @brief Operators for public.eql_v3_timestamp_ord_ope. +--! @brief Operator wrapper for eql_v3.query_text_ord. +--! @param a eql_v3.query_text_ord +--! @param b public.eql_v3_text_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord, b public.eql_v3_text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b eql_v3.query_text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b eql_v3.query_text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord. +--! @param a eql_v3.query_text_ord +--! @param b public.eql_v3_text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord, b public.eql_v3_text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b eql_v3.query_text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b eql_v3.query_text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord. +--! @param a eql_v3.query_text_ord +--! @param b public.eql_v3_text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord, b public.eql_v3_text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b eql_v3.query_text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b eql_v3.query_text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord. +--! @param a eql_v3.query_text_ord +--! @param b public.eql_v3_text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord, b public.eql_v3_text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b eql_v3.query_text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b eql_v3.query_text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord. +--! @param a eql_v3.query_text_ord +--! @param b public.eql_v3_text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord, b public.eql_v3_text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @file encrypted_domain/text/text_ord_ore_functions.sql +--! @brief Functions for public.eql_v3_text_ord_ore. -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Index extractor for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord_ore) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Index extractor for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_text_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord_ore) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ore) = eql_v3.eq_term(b) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord_ore) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ore) <> eql_v3.eq_term(b) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) < eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) <= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) > eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) >= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param selector text +--! @return public.eql_v3_text_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ore, selector text) +RETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param selector integer +--! @return public.eql_v3_text_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ore, selector integer) +RETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a jsonb +--! @param selector public.eql_v3_text_ord_ore +--! @return public.eql_v3_text_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_ord_ore) +RETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a jsonb +--! @param selector public.eql_v3_text_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; ---! @file encrypted_domain/timestamp/timestamp_ord_operators.sql ---! @brief Operators for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b public.eql_v3_text_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/timestamp/timestamp_functions.sql ---! @brief Functions for public.eql_v3_timestamp. +--! @file encrypted_domain/text/text_eq_functions.sql +--! @brief Functions for public.eql_v3_text_eq. ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp +--! @brief Index extractor for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b public.eql_v3_timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b public.eql_v3_text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Operator wrapper for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_eq) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Operator wrapper for public.eql_v3_text_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) = eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp +--! @brief Operator wrapper for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b public.eql_v3_timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b public.eql_v3_text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Operator wrapper for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_eq) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Operator wrapper for public.eql_v3_text_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) <> eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b jsonb) +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp) +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b jsonb) +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp) +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b jsonb) +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp) +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b jsonb) +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp) +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param selector text ---! @return public.eql_v3_timestamp -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp, selector text) -RETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$ +--! @return public.eql_v3_text_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_eq, selector text) +RETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param selector integer ---! @return public.eql_v3_timestamp -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp, selector integer) -RETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$ +--! @return public.eql_v3_text_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_eq, selector integer) +RETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. --! @param a jsonb ---! @param selector public.eql_v3_timestamp ---! @return public.eql_v3_timestamp -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp) -RETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$ +--! @param selector public.eql_v3_text_eq +--! @return public.eql_v3_text_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_eq) +RETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. --! @param a jsonb ---! @param selector public.eql_v3_timestamp +--! @param selector public.eql_v3_text_eq --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_eq) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b public.eql_v3_text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_eq, b public.eql_v3_text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a jsonb +--! @param b public.eql_v3_text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b public.eql_v3_text_eq --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp +--! @param b public.eql_v3_text_eq --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/timestamp/query_timestamp_ord_ore_functions.sql ---! @brief Functions for eql_v3.query_timestamp_ord_ore. +--! @file encrypted_domain/text/text_search_functions.sql +--! @brief Functions for public.eql_v3_text_search. ---! @brief Index extractor for eql_v3.query_timestamp_ord_ore. ---! @param a eql_v3.query_timestamp_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_timestamp_ord_ore) -RETURNS eql_v3_internal.ore_block_256 +--! @brief Index extractor for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_search) +RETURNS eql_v3_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b eql_v3.query_timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +--! @brief Index extractor for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_search) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. ---! @param a eql_v3.query_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +--! @brief Index extractor for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @return eql_v3_internal.bloom_filter +CREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_search) +RETURNS eql_v3_internal.bloom_filter +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b eql_v3.query_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. ---! @param a eql_v3.query_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_search) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b eql_v3.query_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a jsonb +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. ---! @param a eql_v3.query_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b eql_v3.query_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_search) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. ---! @param a eql_v3.query_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a jsonb +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b eql_v3.query_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. ---! @param a eql_v3.query_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_search) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b eql_v3.query_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a jsonb +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. ---! @param a eql_v3.query_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/query_timestamp_ord_functions.sql ---! @brief Functions for eql_v3.query_timestamp_ord. - ---! @brief Index extractor for eql_v3.query_timestamp_ord. ---! @param a eql_v3.query_timestamp_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_timestamp_ord) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b eql_v3.query_timestamp_ord +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_search) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord. ---! @param a eql_v3.query_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a jsonb +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b eql_v3.query_timestamp_ord +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord. ---! @param a eql_v3.query_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_search) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b eql_v3.query_timestamp_ord +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a jsonb +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord. ---! @param a eql_v3.query_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b eql_v3.query_timestamp_ord +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_search) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord. ---! @param a eql_v3.query_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a jsonb +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b eql_v3.query_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b public.eql_v3_text_search) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord. ---! @param a eql_v3.query_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b eql_v3.query_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a jsonb +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord. ---! @param a eql_v3.query_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/query_timestamp_ord_ope_functions.sql ---! @brief Functions for eql_v3.query_timestamp_ord_ope. - ---! @brief Index extractor for eql_v3.query_timestamp_ord_ope. ---! @param a eql_v3.query_timestamp_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_timestamp_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b public.eql_v3_text_search) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b eql_v3.query_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. ---! @param a eql_v3.query_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a jsonb +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b eql_v3.query_timestamp_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param selector text +--! @return public.eql_v3_text_search +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search, selector text) +RETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. ---! @param a eql_v3.query_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param selector integer +--! @return public.eql_v3_text_search +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search, selector integer) +RETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b eql_v3.query_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a jsonb +--! @param selector public.eql_v3_text_search +--! @return public.eql_v3_text_search +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_search) +RETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a jsonb +--! @param selector public.eql_v3_text_search +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_search) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b text --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_search, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. ---! @param a eql_v3.query_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_search, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b eql_v3.query_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_search, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. ---! @param a eql_v3.query_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_search, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b eql_v3.query_timestamp_ord_ope +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope) +CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. ---! @param a eql_v3.query_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b eql_v3.query_timestamp_ord_ope +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a jsonb +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope) +CREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search) @> eql_v3.match_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. ---! @param a eql_v3.query_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_search, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_search, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_search, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_search, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b public.eql_v3_text_search +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search, b public.eql_v3_text_search) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a jsonb +--! @param b public.eql_v3_text_search +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_search) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/timestamp/query_timestamp_eq_functions.sql ---! @brief Functions for eql_v3.query_timestamp_eq. +--! @file encrypted_domain/text/text_search_ore_functions.sql +--! @brief Functions for public.eql_v3_text_search_ore. ---! @brief Index extractor for eql_v3.query_timestamp_eq. ---! @param a eql_v3.query_timestamp_eq +--! @brief Index extractor for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore --! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_timestamp_eq) +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_search_ore) RETURNS eql_v3_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b eql_v3.query_timestamp_eq +--! @brief Index extractor for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_text_search_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Index extractor for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @return eql_v3_internal.bloom_filter +CREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_search_ore) +RETURNS eql_v3_internal.bloom_filter +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; + +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b public.eql_v3_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b eql_v3.query_timestamp_eq) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_eq. ---! @param a eql_v3.query_timestamp_eq ---! @param b public.eql_v3_timestamp_eq +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_eq, b public.eql_v3_timestamp_eq) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_search_ore) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b eql_v3.query_timestamp_eq +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b eql_v3.query_timestamp_eq) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search_ore) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_eq. ---! @param a eql_v3.query_timestamp_eq ---! @param b public.eql_v3_timestamp_eq +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b public.eql_v3_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_eq, b public.eql_v3_timestamp_eq) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; --- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_search_ore_operators.sql ---! @brief Operators for public.eql_v3_text_search_ore. +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_search_ore) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search_ore) <> eql_v3.eq_term(b) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) < eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) <= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) > eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) >= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param selector text +--! @return public.eql_v3_text_search_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search_ore, selector text) +RETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param selector integer +--! @return public.eql_v3_text_search_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search_ore, selector integer) +RETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a jsonb +--! @param selector public.eql_v3_text_search_ore +--! @return public.eql_v3_text_search_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_search_ore) +RETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a jsonb +--! @param selector public.eql_v3_text_search_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_search_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_search_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_search_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_search_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_search_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[] -); +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[] -); +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search_ore) $$; -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonpath -); +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search_ore) @> eql_v3.match_term(b) $$; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_search_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_search_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_search_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_search_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_search_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_search_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_search_operators.sql ---! @brief Operators for public.eql_v3_text_search. +--! @file encrypted_domain/text/text_ord_ore_operators.sql +--! @brief Operators for public.eql_v3_text_ord_ore. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_search, RIGHTARG = text + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_search, RIGHTARG = integer + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_search, RIGHTARG = text + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_search, RIGHTARG = integer + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_text_search, RIGHTARG = text + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_text_search, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_text_search, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_text_search, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_text_search, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_search, RIGHTARG = text + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_search, RIGHTARG = integer + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_search, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_text_search, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_ord_ore_operators.sql ---! @brief Operators for public.eql_v3_text_ord_ore. +--! @file encrypted_domain/text/text_ord_operators.sql +--! @brief Operators for public.eql_v3_text_ord. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore + LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore + LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_text_ord, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_text_ord, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_text_ord, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_text_ord, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore + LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_ord_ope_operators.sql ---! @brief Operators for public.eql_v3_text_ord_ope. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @file encrypted_domain/timestamp/timestamp_ord_ore_functions.sql +--! @brief Functions for public.eql_v3_timestamp_ord_ore. -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Index extractor for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_timestamp_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) = eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) <> eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) < eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) <= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) > eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope -); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb -); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) >= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param selector text +--! @return public.eql_v3_timestamp_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ore, selector text) +RETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param selector integer +--! @return public.eql_v3_timestamp_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ore, selector integer) +RETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a jsonb +--! @param selector public.eql_v3_timestamp_ord_ore +--! @return public.eql_v3_timestamp_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_ord_ore) +RETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a jsonb +--! @param selector public.eql_v3_timestamp_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_ord_operators.sql ---! @brief Operators for public.eql_v3_text_ord. +--! @file encrypted_domain/timestamp/timestamp_ord_functions.sql +--! @brief Functions for public.eql_v3_timestamp_ord. + +--! @brief Index extractor for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_timestamp_ord) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param selector text +--! @return public.eql_v3_timestamp_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord, selector text) +RETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param selector integer +--! @return public.eql_v3_timestamp_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord, selector integer) +RETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a jsonb +--! @param selector public.eql_v3_timestamp_ord +--! @return public.eql_v3_timestamp_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_ord) +RETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a jsonb +--! @param selector public.eql_v3_timestamp_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_operators.sql +--! @brief Operators for public.eql_v3_timestamp_ord. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_functions.sql ---! @brief Functions for public.eql_v3_text. +--! @file encrypted_domain/timestamp/query_timestamp_eq_functions.sql +--! @brief Functions for eql_v3.query_timestamp_eq. ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text +--! @brief Index extractor for eql_v3.query_timestamp_eq. +--! @param a eql_v3.query_timestamp_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_timestamp_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b eql_v3.query_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b public.eql_v3_text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b eql_v3.query_timestamp_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Operator wrapper for eql_v3.query_timestamp_eq. +--! @param a eql_v3.query_timestamp_eq +--! @param b public.eql_v3_timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_eq, b public.eql_v3_timestamp_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b eql_v3.query_timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b eql_v3.query_timestamp_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_eq. +--! @param a eql_v3.query_timestamp_eq +--! @param b public.eql_v3_timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_eq, b public.eql_v3_timestamp_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ope_functions.sql +--! @brief Functions for public.eql_v3_timestamp_ord_ope. + +--! @brief Index extractor for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_timestamp_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) = eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b public.eql_v3_text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) <> eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b public.eql_v3_text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b public.eql_v3_text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b public.eql_v3_text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b public.eql_v3_text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b public.eql_v3_text) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b public.eql_v3_text) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param selector text ---! @return public.eql_v3_text -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text, selector text) -RETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$ +--! @return public.eql_v3_timestamp_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ope, selector text) +RETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param selector integer ---! @return public.eql_v3_text -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text, selector integer) -RETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$ +--! @return public.eql_v3_timestamp_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ope, selector integer) +RETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. --! @param a jsonb ---! @param selector public.eql_v3_text ---! @return public.eql_v3_text -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text) -RETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$ +--! @param selector public.eql_v3_timestamp_ord_ope +--! @return public.eql_v3_timestamp_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_ord_ope) +RETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. --! @param a jsonb ---! @param selector public.eql_v3_text +--! @param selector public.eql_v3_timestamp_ord_ope --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonpath +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text'; END; $$ +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text'; END; $$ +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text, b public.eql_v3_text) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text +--! @param b public.eql_v3_timestamp_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/query_text_search_ore_functions.sql ---! @brief Functions for eql_v3.query_text_search_ore. +--! @file encrypted_domain/timestamp/timestamp_ord_ope_operators.sql +--! @brief Operators for public.eql_v3_timestamp_ord_ope. ---! @brief Index extractor for eql_v3.query_text_search_ore. ---! @param a eql_v3.query_text_search_ore ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_search_ore) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Index extractor for eql_v3.query_text_search_ore. ---! @param a eql_v3.query_text_search_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_text_search_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Index extractor for eql_v3.query_text_search_ore. ---! @param a eql_v3.query_text_search_ore ---! @return eql_v3_internal.bloom_filter -CREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_search_ore) -RETURNS eql_v3_internal.bloom_filter -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b eql_v3.query_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a eql_v3.query_text_search_ore ---! @param b public.eql_v3_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b eql_v3.query_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a eql_v3.query_text_search_ore ---! @param b public.eql_v3_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b eql_v3.query_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a eql_v3.query_text_search_ore ---! @param b public.eql_v3_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b eql_v3.query_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a eql_v3.query_text_search_ore ---! @param b public.eql_v3_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b eql_v3.query_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a eql_v3.query_text_search_ore ---! @param b public.eql_v3_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b eql_v3.query_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a eql_v3.query_text_search_ore ---! @param b public.eql_v3_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b eql_v3.query_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.contains(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a eql_v3.query_text_search_ore ---! @param b public.eql_v3_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b eql_v3.query_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a eql_v3.query_text_search_ore ---! @param b public.eql_v3_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope +); ---! @file encrypted_domain/text/query_text_search_functions.sql ---! @brief Functions for eql_v3.query_text_search. +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb +); ---! @brief Index extractor for eql_v3.query_text_search. ---! @param a eql_v3.query_text_search ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_search) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope +); ---! @brief Index extractor for eql_v3.query_text_search. ---! @param a eql_v3.query_text_search ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_search) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope +); ---! @brief Index extractor for eql_v3.query_text_search. ---! @param a eql_v3.query_text_search ---! @return eql_v3_internal.bloom_filter -CREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_search) -RETURNS eql_v3_internal.bloom_filter -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb +); ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a public.eql_v3_text_search ---! @param b eql_v3.query_text_search ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b eql_v3.query_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope +); ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a eql_v3.query_text_search ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_search, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text +); ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a public.eql_v3_text_search ---! @param b eql_v3.query_text_search ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b eql_v3.query_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer +); ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a eql_v3.query_text_search ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_search, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope +); ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a public.eql_v3_text_search ---! @param b eql_v3.query_text_search ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b eql_v3.query_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text +); ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a eql_v3.query_text_search ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_search, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer +); ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a public.eql_v3_text_search ---! @param b eql_v3.query_text_search ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b eql_v3.query_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope +); ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a eql_v3.query_text_search ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_search, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text +); ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a public.eql_v3_text_search ---! @param b eql_v3.query_text_search ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b eql_v3.query_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a eql_v3.query_text_search ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_search, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a public.eql_v3_text_search ---! @param b eql_v3.query_text_search ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b eql_v3.query_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonpath +); ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a eql_v3.query_text_search ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_search, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope +); ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a public.eql_v3_text_search ---! @param b eql_v3.query_text_search ---! @return boolean -CREATE FUNCTION eql_v3.contains(a public.eql_v3_text_search, b eql_v3.query_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb +); ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a eql_v3.query_text_search ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.query_text_search, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope +); ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a public.eql_v3_text_search ---! @param b eql_v3.query_text_search ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_search, b eql_v3.query_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonpath +); ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a eql_v3.query_text_search ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.query_text_search, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/query_text_ord_ore_functions.sql ---! @brief Functions for eql_v3.query_text_ord_ore. - ---! @brief Index extractor for eql_v3.query_text_ord_ore. ---! @param a eql_v3.query_text_ord_ore ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord_ore) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Index extractor for eql_v3.query_text_ord_ore. ---! @param a eql_v3.query_text_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_text_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b eql_v3.query_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ore. ---! @param a eql_v3.query_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b eql_v3.query_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ore. ---! @param a eql_v3.query_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b eql_v3.query_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ore. ---! @param a eql_v3.query_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b eql_v3.query_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ore. ---! @param a eql_v3.query_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b eql_v3.query_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ore. ---! @param a eql_v3.query_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b eql_v3.query_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ore. ---! @param a eql_v3.query_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/query_text_ord_functions.sql ---! @brief Functions for eql_v3.query_text_ord. - ---! @brief Index extractor for eql_v3.query_text_ord. ---! @param a eql_v3.query_text_ord ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Index extractor for eql_v3.query_text_ord. ---! @param a eql_v3.query_text_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_ord) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b eql_v3.query_text_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b eql_v3.query_text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord. ---! @param a eql_v3.query_text_ord ---! @param b public.eql_v3_text_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord, b public.eql_v3_text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b eql_v3.query_text_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b eql_v3.query_text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord. ---! @param a eql_v3.query_text_ord ---! @param b public.eql_v3_text_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord, b public.eql_v3_text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b eql_v3.query_text_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b eql_v3.query_text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord. ---! @param a eql_v3.query_text_ord ---! @param b public.eql_v3_text_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord, b public.eql_v3_text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b eql_v3.query_text_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b eql_v3.query_text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord. ---! @param a eql_v3.query_text_ord ---! @param b public.eql_v3_text_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord, b public.eql_v3_text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b eql_v3.query_text_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b eql_v3.query_text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord. ---! @param a eql_v3.query_text_ord ---! @param b public.eql_v3_text_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord, b public.eql_v3_text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b eql_v3.query_text_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b eql_v3.query_text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord. ---! @param a eql_v3.query_text_ord ---! @param b public.eql_v3_text_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord, b public.eql_v3_text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/query_text_ord_ope_functions.sql ---! @brief Functions for eql_v3.query_text_ord_ope. - ---! @brief Index extractor for eql_v3.query_text_ord_ope. ---! @param a eql_v3.query_text_ord_ope ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord_ope) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Index extractor for eql_v3.query_text_ord_ope. ---! @param a eql_v3.query_text_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b eql_v3.query_text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ope. ---! @param a eql_v3.query_text_ord_ope ---! @param b public.eql_v3_text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b eql_v3.query_text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ope. ---! @param a eql_v3.query_text_ord_ope ---! @param b public.eql_v3_text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b eql_v3.query_text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ope. ---! @param a eql_v3.query_text_ord_ope ---! @param b public.eql_v3_text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b eql_v3.query_text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ope. ---! @param a eql_v3.query_text_ord_ope ---! @param b public.eql_v3_text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b eql_v3.query_text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ope. ---! @param a eql_v3.query_text_ord_ope ---! @param b public.eql_v3_text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b eql_v3.query_text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ope. ---! @param a eql_v3.query_text_ord_ope ---! @param b public.eql_v3_text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/query_text_match_functions.sql ---! @brief Functions for eql_v3.query_text_match. - ---! @brief Index extractor for eql_v3.query_text_match. ---! @param a eql_v3.query_text_match ---! @return eql_v3_internal.bloom_filter -CREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_match) -RETURNS eql_v3_internal.bloom_filter -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.query_text_match. ---! @param a public.eql_v3_text_match ---! @param b eql_v3.query_text_match ---! @return boolean -CREATE FUNCTION eql_v3.contains(a public.eql_v3_text_match, b eql_v3.query_text_match) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_match. ---! @param a eql_v3.query_text_match ---! @param b public.eql_v3_text_match ---! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.query_text_match, b public.eql_v3_text_match) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_text_match. ---! @param a public.eql_v3_text_match ---! @param b eql_v3.query_text_match ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_match, b eql_v3.query_text_match) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_text_match. ---! @param a eql_v3.query_text_match ---! @param b public.eql_v3_text_match ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.query_text_match, b public.eql_v3_text_match) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text +); ---! @file encrypted_domain/text/query_text_eq_functions.sql ---! @brief Functions for eql_v3.query_text_eq. +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer +); ---! @brief Index extractor for eql_v3.query_text_eq. ---! @param a eql_v3.query_text_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b eql_v3.query_text_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b eql_v3.query_text_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_text_eq. ---! @param a eql_v3.query_text_eq ---! @param b public.eql_v3_text_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_eq, b public.eql_v3_text_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope +); ---! @brief Operator wrapper for eql_v3.query_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b eql_v3.query_text_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b eql_v3.query_text_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb +); ---! @brief Operator wrapper for eql_v3.query_text_eq. ---! @param a eql_v3.query_text_eq ---! @param b public.eql_v3_text_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_eq, b public.eql_v3_text_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope +); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/smallint/smallint_ord_ore_operators.sql ---! @brief Operators for public.eql_v3_smallint_ord_ore. +--! @file encrypted_domain/timestamp/timestamp_ord_ore_operators.sql +--! @brief Operators for public.eql_v3_timestamp_ord_ore. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/smallint_ord_ope_operators.sql ---! @brief Operators for public.eql_v3_smallint_ord_ope. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore ); -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @file v3/json/types.sql +--! @brief Domain types for the eql_v3 encrypted-JSONB (SteVec) surface. +--! +--! Three jsonb-backed domains (none over another domain — operators resolve +--! against the ultimate base type jsonb, so the native-jsonb firewall in +--! blockers.sql can attach): +--! - public.eql_v3_json_search — storage/root: an EQL envelope object ({i, v, ...}). +--! - public.eql_v3_json_entry — a single sv element (returned by `->`). +--! - eql_v3.query_json — a containment needle (sv elements, no ciphertext). -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Validate a single SteVec entry payload. +--! @internal +--! @param val jsonb Candidate entry payload. +--! @return boolean True when `val` is an sv entry with string `s`, string `c`, +--! and exactly one string deterministic term (`hm` XOR `op`). +CREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_entry_payload(val jsonb) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT COALESCE( + jsonb_typeof(val) = 'object' + AND jsonb_typeof(val -> 's') = 'string' + AND jsonb_typeof(val -> 'c') = 'string' + AND ( + (jsonb_typeof(val -> 'hm') = 'string' AND NOT (val ? 'op')) + OR + (jsonb_typeof(val -> 'op') = 'string' AND NOT (val ? 'hm')) + ), + false + ) +$$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Validate a SteVec containment query payload. +--! @internal +--! @param val jsonb Candidate query payload. +--! @return boolean True when `val` is `{"sv":[...]}` and every element carries +--! string `s`, no ciphertext, and exactly one string term (`hm` XOR +--! `op`). +--! @note plpgsql, not LANGUAGE sql (issues #353/#354): the only caller is the +--! eql_v3.query_json domain CHECK, where a SQL function can never be +--! inlined (and the CHECK itself cannot absorb this body — it needs a +--! subquery over the sv elements, which CHECK constraints forbid). plpgsql +--! caches its plan across calls instead of paying the per-call SQL-function +--! executor on every needle cast. +CREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_query_payload(val jsonb) + RETURNS boolean + LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +AS $$ +BEGIN + RETURN COALESCE( + jsonb_typeof(val) = 'object' + AND jsonb_typeof(val -> 'sv') = 'array' + AND NOT EXISTS ( + SELECT 1 + FROM jsonb_array_elements( + CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END + ) AS elem + WHERE NOT COALESCE(( + jsonb_typeof(elem) = 'object' + AND jsonb_typeof(elem -> 's') = 'string' + AND NOT (elem ? 'c') + AND ( + (jsonb_typeof(elem -> 'hm') = 'string' AND NOT (elem ? 'op')) + OR + (jsonb_typeof(elem -> 'op') = 'string' AND NOT (elem ? 'hm')) + ) + ), false) + ), + false + ); +END; +$$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Validate a root SteVec document payload. +--! @internal +--! @param val jsonb Candidate document payload. +--! @return boolean True when `val` is an encrypted document envelope with +--! `v = 3`, `i`, an `sv` array, and valid sv entry elements. +CREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_document_payload(val jsonb) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT COALESCE( + jsonb_typeof(val) = 'object' + AND val ? 'v' + AND val ->> 'v' = '3' + AND val ? 'i' + AND jsonb_typeof(val -> 'sv') = 'array' + AND NOT EXISTS ( + SELECT 1 + FROM jsonb_array_elements( + CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END + ) AS elem + WHERE NOT public.eql_v3_is_valid_ste_vec_entry_payload(elem) + ), + false + ) +$$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Storage/root domain for an encrypted JSONB column. +--! +--! CHECK: a JSON object carrying the EQL envelope (`v = 3` version and `i` index +--! metadata). Root `c` is intentionally NOT required — an sv-array root payload +--! is `{i, v, sv}` with no root ciphertext. The CHECK now also requires an `sv` +--! array, so the domain accepts only SteVec **document** payloads and rejects +--! encrypted *scalar* payloads (which carry `c`/`hm`/`ob` but no `sv`) — this is +--! what keeps `public.eql_v3_json_search` a typed document domain rather than a generic +--! encrypted envelope. The firewall in blockers.sql attaches to this domain to +--! stop native jsonb operators from reaching a column value. +--! +--! @note Constructing from inline JSON uses the standard DOMAIN cast: +--! `'{"i":{},"v":3,"sv":[...]}'::public.eql_v3_json_search`. +DO $$ +BEGIN + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'eql_v3_json_search' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.eql_v3_json_search AS jsonb + CHECK ( + public.eql_v3_is_valid_ste_vec_document_payload(VALUE) + ); + END IF; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); + COMMENT ON DOMAIN public.eql_v3_json_search IS 'EQL encrypted JSONB searchable document (containment)'; +END +$$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Domain type for an individual sv element. +--! +--! A single element inside an `sv` array: a JSON object that carries a selector +--! (`s`), a ciphertext (`c`), and **exactly one** of `hm` (HMAC-256, for +--! hash-equality) or `op` (CLLW OPE, for ordered queries) — they are mutually +--! exclusive. This is the type returned by `->` and accepted by the per-entry +--! extractors `eql_v3.eq_term` / `eql_v3.ord_term`. Extra fields (`a`, root +--! `i`/`v` merged in by `->`) are allowed. +--! +--! @see src/v3/json/operators.sql +--! +--! @internal +--! Implementation note (issue #354): the CHECK is an INLINE expression, not a +--! call to `public.eql_v3_is_valid_ste_vec_entry_payload` — domain +--! constraints cannot inline SQL functions, so the function-call form paid +--! the per-call SQL-function executor (~18 µs) on EVERY cast: the needle +--! cast in every field_eq query (+19% end-to-end vs v2, the entire measured +--! regression on that scenario; see cipherstash/benches#23). The expression +--! mirrors the validator body; the leading `VALUE IS NULL OR` preserves the +--! validator's STRICT NULL-passes semantics (a bare COALESCE(..., false) +--! would reject NULL, which `->` returns for a missing selector). Keep the +--! two in sync — `jsonb_entry_check_matches_validator` in tests/sqlx pins +--! the equivalence. +--! @endinternal +DO $$ +BEGIN + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'eql_v3_json_entry' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.eql_v3_json_entry AS jsonb + CHECK ( + VALUE IS NULL + OR COALESCE( + jsonb_typeof(VALUE) = 'object' + AND jsonb_typeof(VALUE -> 's') = 'string' + AND jsonb_typeof(VALUE -> 'c') = 'string' + AND ( + (jsonb_typeof(VALUE -> 'hm') = 'string' AND NOT (VALUE ? 'op')) + OR + (jsonb_typeof(VALUE -> 'op') = 'string' AND NOT (VALUE ? 'hm')) + ), + false + ) + ); + END IF; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); + COMMENT ON DOMAIN public.eql_v3_json_entry IS 'EQL encrypted JSONB leaf entry (equality, ordering)'; +END +$$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Domain type for an STE-vec containment needle. +--! +--! A query-shaped payload `{"sv":[...]}` whose elements carry selector + index +--! term but **never** a ciphertext (`c`). Each element must carry `s` and +--! exactly one deterministic term (`hm` XOR `op`). Typing the needle this way +--! stops selector-only needles from casting and matching every row via bare +--! `jsonb @>`. +--! +--! @note Construct from inline JSON via the DOMAIN cast: +--! `'{"sv":[{"s":"","hm":""}]}'::eql_v3.query_json`. +--! @see eql_v3.to_ste_vec_query +--! +--! @internal +--! Implementation note (issue #354): this CHECK CANNOT be inlined like +--! public.eql_v3_json_entry's — validating the sv elements requires a subquery +--! (`NOT EXISTS (SELECT ... FROM jsonb_array_elements(...))`), and CHECK +--! constraints forbid subqueries. The validator is plpgsql instead (cached +--! plan; substantially cheaper per call than a non-inlined LANGUAGE sql +--! function — the same finding as issue #353), since this cast sits on the +--! per-query hot path of every containment scenario +--! (`$1::jsonb::eql_v3.query_json`). +--! @endinternal +DO $$ +BEGIN + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_json' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_json AS jsonb + CHECK ( + public.eql_v3_is_valid_ste_vec_query_payload(VALUE) + ); + END IF; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); + COMMENT ON DOMAIN eql_v3.query_json IS 'EQL JSONB query operand (containment)'; +END +$$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Convert a public.eql_v3_json_search to a query_json needle. +--! +--! Normalises each sv element down to the matching-relevant fields: `s` plus +--! exactly one of `hm` / `op`. Other fields (`c`, `a`, `i`/`v`, anything else) +--! are stripped. This is the canonical needle shape for `@>` containment. +--! Designed for use as a functional GIN index expression: +--! `GIN (eql_v3.to_ste_vec_query(col)::jsonb jsonb_path_ops)`. +--! +--! @param e public.eql_v3_json_search Source encrypted payload +--! @return eql_v3.query_json Query-shaped needle, sv elements normalised. +--! @see eql_v3.query_json +CREATE FUNCTION eql_v3.to_ste_vec_query(e public.eql_v3_json_search) + RETURNS eql_v3.query_json + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT jsonb_build_object( + 'sv', + coalesce( + (SELECT jsonb_agg( + jsonb_strip_nulls( + jsonb_build_object( + 's', elem -> 's', + 'hm', elem -> 'hm', + 'op', elem -> 'op' + ) + ) + ) + FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem), + '[]'::jsonb + ) + )::eql_v3.query_json +$$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +CREATE CAST (public.eql_v3_json_search AS eql_v3.query_json) + WITH FUNCTION eql_v3.to_ste_vec_query + AS ASSIGNMENT; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @file v3/json/functions.sql +--! @brief Extractors, containment engine, and path/array functions for the +--! eql_v3 encrypted-JSONB (SteVec) surface. +--! +--! `selector` parameters here are *encrypted-side* selector hashes — the +--! deterministic hash the crypto layer emits in the `s` field of each sv +--! element. Plaintext JSONPaths are never accepted at runtime. -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +------------------------------------------------------------------------------ +-- Envelope helpers (eql_v3 owns these; jsonb-only) +------------------------------------------------------------------------------ -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Extract metadata (i, v) from a raw jsonb encrypted value. +--! @param val jsonb encrypted EQL payload +--! @return jsonb Metadata object with `i` and `v` fields. +CREATE FUNCTION eql_v3.meta_data(val jsonb) + RETURNS jsonb + IMMUTABLE STRICT PARALLEL SAFE + LANGUAGE SQL +AS $$ + SELECT jsonb_build_object('i', val->'i', 'v', val->'v'); +$$; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope -); +COMMENT ON FUNCTION eql_v3.meta_data(jsonb) IS + 'eql-inline-critical: raw-jsonb envelope helper used by v3 jsonb wrappers; must stay inlinable (unpinned search_path)'; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb -); +--! @brief Extract ciphertext (c) from a raw jsonb encrypted value. +--! @param val jsonb encrypted EQL payload +--! @return text Base64-encoded ciphertext. +--! @throws Exception if `c` is absent. +CREATE FUNCTION eql_v3.ciphertext(val jsonb) + RETURNS text + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + BEGIN + IF val ? 'c' THEN + RETURN val->>'c'; + END IF; + RAISE 'Expected a ciphertext (c) value in json: %', val; + END; +$$ LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope -); +------------------------------------------------------------------------------ +-- Selector extractors +------------------------------------------------------------------------------ -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope -); +--! @brief Extract selector (s) from a raw jsonb encrypted value. +--! @param val jsonb encrypted EQL payload +--! @return text The selector value. +--! @throws Exception if `s` is absent. +CREATE FUNCTION eql_v3.selector(val jsonb) + RETURNS text + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + BEGIN + IF val ? 's' THEN + RETURN val->>'s'; + END IF; + RAISE 'Expected a selector index (s) value in json: %', val; + END; +$$ LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb -); +--! @brief Extract selector (s) from a ste_vec entry. The DOMAIN CHECK +--! guarantees `s` is present, so this is a simple field access. +--! @param entry public.eql_v3_json_entry +--! @return text The selector value. +CREATE FUNCTION eql_v3.selector(entry public.eql_v3_json_entry) + RETURNS text + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT entry ->> 's' +$$; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope -); +------------------------------------------------------------------------------ +-- Equality-term extractor (XOR-aware: coalesce(hm, op)) +------------------------------------------------------------------------------ -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text -); +--! @brief XOR-aware equality term extractor for public.eql_v3_json_entry. +--! +--! Returns the bytea of whichever deterministic term the sv entry carries — +--! `hm` (HMAC-256) or `op` (CLLW OPE). The two byte distributions are disjoint +--! by construction, so byte equality on the coalesce is unambiguous. Canonical +--! equality extractor used by `=` / `<>` on jsonb_entry. +--! +--! @param entry public.eql_v3_json_entry +--! @return bytea Decoded `hm` or `op` bytes (NULL if entry is NULL). +CREATE FUNCTION eql_v3.eq_term(entry public.eql_v3_json_entry) + RETURNS bytea + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT decode(coalesce(entry ->> 'hm', entry ->> 'op'), 'hex') +$$; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer -); +------------------------------------------------------------------------------ +-- CLLW OPE per-entry overload (converged with the scalar ord_term) +------------------------------------------------------------------------------ -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope -); +--! @brief Extract the CLLW OPE index term from a ste_vec entry. +--! +--! An sv-element `op` term is only ever present on an sv element, never at a +--! root encrypted value, so the typed overload accepts public.eql_v3_json_entry — +--! the jsonb_entry twin of the generated scalar `eql_v3.ord_term` +--! extractors. Returns SQL NULL when `op` is absent (the strict `->>` / +--! `decode` chain propagates it), so btree NULL-filters such rows from range +--! queries. The returned eql_v3_internal.ope_cllw is a bytea domain: it orders +--! under native byte comparison with the DEFAULT btree opclass, so a +--! functional index on `eql_v3.ord_term(col -> 'selector')` engages +--! structurally with no custom operator class (Supabase/managed-Postgres +--! safe). +--! +--! @param entry public.eql_v3_json_entry +--! @return eql_v3_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when +--! `op` is absent. +CREATE FUNCTION eql_v3.ord_term(entry public.eql_v3_json_entry) + RETURNS eql_v3_internal.ope_cllw + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.ope_cllw(entry::jsonb) +$$; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text -); +------------------------------------------------------------------------------ +-- sv-array helpers +------------------------------------------------------------------------------ -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer -); +--! @brief Extract the sv element array as raw jsonb[]. +--! +--! Returns the elements of `sv` (or a single-element array wrapping the value +--! when there is no `sv`). No envelope re-wrapping — raw jsonb elements. +--! +--! @param val jsonb encrypted EQL payload +--! @return jsonb[] Array of sv elements. +CREATE FUNCTION eql_v3.ste_vec(val jsonb) + RETURNS jsonb[] + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + sv jsonb; + ary jsonb[]; + BEGIN + IF val ? 'sv' THEN + sv := val->'sv'; + ELSE + sv := jsonb_build_array(val); + END IF; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope -); + SELECT array_agg(elem) + INTO ary + FROM jsonb_array_elements(sv) AS elem; -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text -); + RETURN ary; + END; +$$ LANGUAGE plpgsql; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[] -); +--! @brief Check if a jsonb payload is marked as an sv array (`a` flag true). +--! @param val jsonb encrypted EQL payload +--! @return boolean True if `a` is present and true. +CREATE FUNCTION eql_v3_internal.is_ste_vec_array(val jsonb) + RETURNS boolean + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + BEGIN + IF val ? 'a' THEN + RETURN (val->>'a')::boolean; + END IF; + RETURN false; + END; +$$ LANGUAGE plpgsql; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[] -); +------------------------------------------------------------------------------ +-- Deterministic-fields array for GIN containment +------------------------------------------------------------------------------ -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonpath -); +--! @brief Extract deterministic search fields (s, hm, op) per sv element. +--! +--! Excludes non-deterministic ciphertext so PostgreSQL's native jsonb `@>` can +--! compare for containment. Use for GIN indexes and containment queries. +--! +--! @param val jsonb encrypted EQL payload +--! @return jsonb[] Array of objects with only deterministic fields. +CREATE FUNCTION eql_v3.jsonb_array(val jsonb) +RETURNS jsonb[] +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE SQL +AS $$ + SELECT ARRAY( + SELECT jsonb_object_agg(kv.key, kv.value) + FROM jsonb_array_elements( + CASE WHEN val ? 'sv' THEN val->'sv' ELSE jsonb_build_array(val) END + ) AS elem, + LATERAL jsonb_each(elem) AS kv(key, value) + WHERE kv.key IN ('s', 'hm', 'op') + GROUP BY elem + ); +$$; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonpath -); +COMMENT ON FUNCTION eql_v3.jsonb_array(jsonb) IS + 'eql-inline-critical: raw-jsonb deterministic-field array helper; must stay inlinable (unpinned search_path)'; -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[] -); +------------------------------------------------------------------------------ +-- Containment +------------------------------------------------------------------------------ -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[] -); +--! @brief GIN-indexable containment check: does `a` contain all of `b`? +--! @param a jsonb Container payload. +--! @param b jsonb Search payload. +--! @return boolean True if a contains all deterministic elements of b. +--! @note Public raw-`jsonb[]` containment helper over the extracted +--! deterministic fields — the function-form entrypoint for containment on +--! platforms without operator support (Supabase/PostgREST). The typed +--! `public.eql_v3_json_search` `@>` operator does NOT call this function — it binds to +--! `eql_v3.ste_vec_contains` instead — but both agree on the result (a +--! parity test pins this). Also the documented GIN index expression +--! (`eql_v3.jsonb_array(col)`); see docs/reference/database-indexes.md. +CREATE FUNCTION eql_v3.jsonb_contains(a jsonb, b jsonb) +RETURNS boolean +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE SQL +AS $$ + SELECT eql_v3.jsonb_array(a) @> eql_v3.jsonb_array(b); +$$; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text -); +COMMENT ON FUNCTION eql_v3.jsonb_contains(jsonb, jsonb) IS + 'eql-inline-critical: raw-jsonb containment helper; must stay inlinable (unpinned search_path)'; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer -); +--! @brief GIN-indexable "is contained by" check. +--! @param a jsonb Payload to check. +--! @param b jsonb Container payload. +--! @return boolean True if all elements of a are contained in b. +--! @note Public raw-`jsonb[]` reverse-containment helper — the function-form +--! entrypoint for `<@` on platforms without operator support. The typed +--! `public.eql_v3_json_search` `<@` operator binds to `eql_v3.ste_vec_contains` instead, +--! but both agree on the result. +CREATE FUNCTION eql_v3.jsonb_contained_by(a jsonb, b jsonb) +RETURNS boolean +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE SQL +AS $$ + SELECT eql_v3.jsonb_array(a) <@ eql_v3.jsonb_array(b); +$$; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[] -); +COMMENT ON FUNCTION eql_v3.jsonb_contained_by(jsonb, jsonb) IS + 'eql-inline-critical: raw-jsonb contained-by helper; must stay inlinable (unpinned search_path)'; -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[] -); +--! @brief Check if an sv array contains a specific sv element. +--! +--! Match = selector equal AND eq_term equal (byte-equality over coalesce(hm, +--! op)). This collapses the v2 hm/oc CASE: under the XOR contract both terms +--! are deterministic and byte-disjoint, so either one is a valid equality +--! discriminator and a single byte comparison is correct. +--! +--! ASSUMPTION (locked by a negative test in v3_jsonb_tests.rs): hm and op byte +--! distributions never collide at a given selector. The crypto layer configures +--! a selector for eq XOR ordered, so both sides of a real comparison carry the +--! same term type — an hm needle never meets an op leaf at the same selector. +--! This collapse would wrongly match an hm needle against an op leaf if their +--! hex bytes were ever identical — which the contract prevents (an hm is a +--! fixed 32-byte HMAC; an op is a CLLW OPE ciphertext whose length is a +--! function of the plaintext bit width, never 32 bytes for the supported +--! domains). The negative-containment test guards against regression. +--! +--! @param a jsonb[] sv array to search within. +--! @param b jsonb sv element to search for. +--! @return boolean True if b is found in any element of a. +CREATE FUNCTION eql_v3.ste_vec_contains(a jsonb[], b jsonb) + RETURNS boolean + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + result boolean; + _a jsonb; + BEGIN + result := false; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope -); + FOR idx IN 1..array_length(a, 1) LOOP + _a := a[idx]; + result := result OR ( + eql_v3.selector(_a) = eql_v3.selector(b) + AND eql_v3.eq_term(_a::public.eql_v3_json_entry) = eql_v3.eq_term(b::public.eql_v3_json_entry) + ); + EXIT WHEN result; + END LOOP; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb -); + RETURN result; + END; +$$ LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Does encrypted value `a` contain all sv elements of `b`? +--! +--! Empty b is always contained. Each element of b must match selector + eq_term +--! in some element of a. +--! +--! @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. +--! @see eql_v3.ste_vec_contains(jsonb[], jsonb) +CREATE FUNCTION eql_v3.ste_vec_contains(a public.eql_v3_json_search, b public.eql_v3_json_search) + RETURNS boolean + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + result boolean; + sv_a jsonb[]; + sv_b jsonb[]; + _b jsonb; + BEGIN + sv_a := eql_v3.ste_vec(a); + sv_b := eql_v3.ste_vec(b); ---! @file encrypted_domain/smallint/smallint_ord_operators.sql ---! @brief Operators for public.eql_v3_smallint_ord. + IF array_length(sv_b, 1) IS NULL THEN + RETURN true; + END IF; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); + IF array_length(sv_a, 1) IS NULL THEN + RETURN false; + END IF; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); + result := true; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); + FOR idx IN 1..array_length(sv_b, 1) LOOP + _b := sv_b[idx]; + result := result AND eql_v3.ste_vec_contains(sv_a, _b); + END LOOP; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); + RETURN result; + END; +$$ LANGUAGE plpgsql; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +------------------------------------------------------------------------------ +-- Path queries (text selector only) +------------------------------------------------------------------------------ -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Query encrypted JSONB for sv elements matching `selector`. +--! +--! Returns one jsonb_entry row per matching encrypted element. Returns empty +--! set on no match. It deliberately does not wrap multiple matches as an +--! public.eql_v3_json_search document, because the root document domain requires an `sv` +--! array and single leaves belong to public.eql_v3_json_entry. +--! +--! @param val jsonb encrypted EQL payload with `sv`. +--! @param selector text Selector hash (`s` value). +--! @return SETOF public.eql_v3_json_entry Matching encrypted entries. +--! @see eql_v3.jsonb_path_query_first +CREATE FUNCTION eql_v3.jsonb_path_query(val jsonb, selector text) + RETURNS SETOF public.eql_v3_json_entry + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_entry + FROM jsonb_array_elements(val -> 'sv') elem + WHERE elem ->> 's' = selector +$$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +COMMENT ON FUNCTION eql_v3.jsonb_path_query(jsonb, text) IS + 'eql-inline-critical: raw-jsonb path query helper; must stay inlinable (unpinned search_path)'; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Check if a selector path exists in encrypted JSONB. +--! @param val jsonb encrypted EQL payload. +--! @param selector text Selector hash to test. +--! @return boolean True if a matching element exists. +CREATE FUNCTION eql_v3.jsonb_path_exists(val jsonb, selector text) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT EXISTS ( + SELECT 1 FROM jsonb_array_elements(val -> 'sv') elem + WHERE elem ->> 's' = selector + ); +$$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +COMMENT ON FUNCTION eql_v3.jsonb_path_exists(jsonb, text) IS + 'eql-inline-critical: raw-jsonb path exists helper; must stay inlinable (unpinned search_path)'; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Get the first sv element matching `selector`, or NULL. +--! @param val jsonb encrypted EQL payload. +--! @param selector text Selector hash to match. +--! @return public.eql_v3_json_entry First matching element or NULL. +CREATE FUNCTION eql_v3.jsonb_path_query_first(val jsonb, selector text) + RETURNS public.eql_v3_json_entry + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_entry + FROM jsonb_array_elements(val -> 'sv') elem + WHERE elem ->> 's' = selector + LIMIT 1 +$$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +COMMENT ON FUNCTION eql_v3.jsonb_path_query_first(jsonb, text) IS + 'eql-inline-critical: raw-jsonb path first helper; must stay inlinable (unpinned search_path)'; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +------------------------------------------------------------------------------ +-- Array functions +------------------------------------------------------------------------------ -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Get the length of an encrypted JSONB array. +--! @param val jsonb encrypted EQL payload (must have `a` flag true). +--! @return integer Number of elements. +--! @throws Exception 'cannot get array length of a non-array' if not an array. +CREATE FUNCTION eql_v3.jsonb_array_length(val jsonb) + RETURNS integer + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + sv jsonb[]; + BEGIN + IF eql_v3_internal.is_ste_vec_array(val) THEN + sv := eql_v3.ste_vec(val); + RETURN array_length(sv, 1); + END IF; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); + RAISE 'cannot get array length of a non-array'; + END; +$$ LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Extract elements of an encrypted JSONB array as rows. +--! @param val jsonb encrypted EQL payload (must have `a` flag true). +--! @return SETOF public.eql_v3_json_entry One row per element (metadata preserved). +--! @throws Exception 'cannot extract elements from non-array' if not an array. +CREATE FUNCTION eql_v3.jsonb_array_elements(val jsonb) + RETURNS SETOF public.eql_v3_json_entry + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + sv jsonb[]; + meta jsonb; + item jsonb; + BEGIN + IF NOT eql_v3_internal.is_ste_vec_array(val) THEN + RAISE 'cannot extract elements from non-array'; + END IF; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); + meta := eql_v3.meta_data(val); + sv := eql_v3.ste_vec(val); -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); + FOR idx IN 1..array_length(sv, 1) LOOP + item = sv[idx]; + RETURN NEXT (meta || item)::public.eql_v3_json_entry; + END LOOP; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); + RETURN; + END; +$$ LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord -); +--! @brief Extract elements of an encrypted JSONB array as ciphertext text. +--! @param val jsonb encrypted EQL payload (must have `a` flag true). +--! @return SETOF text One ciphertext per element. +--! @throws Exception 'cannot extract elements from non-array' if not an array. +CREATE FUNCTION eql_v3.jsonb_array_elements_text(val jsonb) + RETURNS SETOF text + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + sv jsonb[]; + BEGIN + IF NOT eql_v3_internal.is_ste_vec_array(val) THEN + RAISE 'cannot extract elements from non-array'; + END IF; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb -); + sv := eql_v3.ste_vec(val); -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord -); + FOR idx IN 1..array_length(sv, 1) LOOP + RETURN NEXT eql_v3.ciphertext(sv[idx]); + END LOOP; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord -); + RETURN; + END; +$$ LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE +-- Source is src/v3/version.template -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb -); +DROP FUNCTION IF EXISTS eql_v3.version(); -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord -); +--! @file v3/version.sql +--! @brief EQL version reporting (self-contained eql_v3 surface) +--! +--! This file is auto-generated from src/v3/version.template during build. +--! The 3.0.0 placeholder is replaced with the actual release +--! version (bare semver, e.g. "3.0.0") supplied via `mise run build --version`, +--! or "DEV" for development builds. -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text -); +--! @brief Get the installed EQL version string +--! +--! Returns the version string for the installed EQL library. This value is +--! baked in at build time from the release tag. +--! +--! @return text Version string (e.g. "3.0.0" or "DEV" for development builds) +--! +--! @note Auto-generated during build from src/v3/version.template +--! +--! Example: `SELECT eql_v3.version()` returns the installed version string, +--! e.g. `'3.0.0'` (or `'DEV'` for development builds). +CREATE FUNCTION eql_v3.version() + RETURNS text + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT '3.0.0'; +$$ LANGUAGE SQL; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer -); +--! @brief Schema-level version marker for obj_description() discoverability +--! +--! Mirrors eql_v3.version() as a comment on the schema so the installed +--! version can also be read via obj_description('eql_v3'::regnamespace). +COMMENT ON SCHEMA eql_v3 IS '3.0.0'; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/smallint_functions.sql ---! @brief Functions for public.eql_v3_smallint. - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b public.eql_v3_smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b public.eql_v3_smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b public.eql_v3_smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b public.eql_v3_smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b public.eql_v3_smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b public.eql_v3_smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b public.eql_v3_smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b public.eql_v3_smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param selector text ---! @return public.eql_v3_smallint -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint, selector text) -RETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param selector integer ---! @return public.eql_v3_smallint -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint, selector integer) -RETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param selector public.eql_v3_smallint ---! @return public.eql_v3_smallint -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint) -RETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param selector public.eql_v3_smallint ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint, b public.eql_v3_smallint) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/query_smallint_ord_ore_functions.sql ---! @brief Functions for eql_v3.query_smallint_ord_ore. - ---! @brief Index extractor for eql_v3.query_smallint_ord_ore. ---! @param a eql_v3.query_smallint_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_smallint_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b eql_v3.query_smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. ---! @param a eql_v3.query_smallint_ord_ore ---! @param b public.eql_v3_smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b eql_v3.query_smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. ---! @param a eql_v3.query_smallint_ord_ore ---! @param b public.eql_v3_smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b eql_v3.query_smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. ---! @param a eql_v3.query_smallint_ord_ore ---! @param b public.eql_v3_smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b eql_v3.query_smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. ---! @param a eql_v3.query_smallint_ord_ore ---! @param b public.eql_v3_smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b eql_v3.query_smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. ---! @param a eql_v3.query_smallint_ord_ore ---! @param b public.eql_v3_smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b eql_v3.query_smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. ---! @param a eql_v3.query_smallint_ord_ore ---! @param b public.eql_v3_smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/query_smallint_ord_functions.sql ---! @brief Functions for eql_v3.query_smallint_ord. - ---! @brief Index extractor for eql_v3.query_smallint_ord. ---! @param a eql_v3.query_smallint_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_smallint_ord) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b eql_v3.query_smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord. ---! @param a eql_v3.query_smallint_ord ---! @param b public.eql_v3_smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b eql_v3.query_smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord. ---! @param a eql_v3.query_smallint_ord ---! @param b public.eql_v3_smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b eql_v3.query_smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord. ---! @param a eql_v3.query_smallint_ord ---! @param b public.eql_v3_smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b eql_v3.query_smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord. ---! @param a eql_v3.query_smallint_ord ---! @param b public.eql_v3_smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b eql_v3.query_smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord. ---! @param a eql_v3.query_smallint_ord ---! @param b public.eql_v3_smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b eql_v3.query_smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord. ---! @param a eql_v3.query_smallint_ord ---! @param b public.eql_v3_smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/query_smallint_ord_ope_functions.sql ---! @brief Functions for eql_v3.query_smallint_ord_ope. - ---! @brief Index extractor for eql_v3.query_smallint_ord_ope. ---! @param a eql_v3.query_smallint_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_smallint_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b eql_v3.query_smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. ---! @param a eql_v3.query_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b eql_v3.query_smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. ---! @param a eql_v3.query_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b eql_v3.query_smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. ---! @param a eql_v3.query_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b eql_v3.query_smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. ---! @param a eql_v3.query_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b eql_v3.query_smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. ---! @param a eql_v3.query_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b eql_v3.query_smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. ---! @param a eql_v3.query_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/query_smallint_eq_functions.sql ---! @brief Functions for eql_v3.query_smallint_eq. - ---! @brief Index extractor for eql_v3.query_smallint_eq. ---! @param a eql_v3.query_smallint_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_smallint_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b eql_v3.query_smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b eql_v3.query_smallint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_eq. ---! @param a eql_v3.query_smallint_eq ---! @param b public.eql_v3_smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_eq, b public.eql_v3_smallint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b eql_v3.query_smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b eql_v3.query_smallint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_eq. ---! @param a eql_v3.query_smallint_eq ---! @param b public.eql_v3_smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_eq, b public.eql_v3_smallint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/real/real_ord_ore_operators.sql ---! @brief Operators for public.eql_v3_real_ord_ore. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief EQL lint: detect non-inlinable operator implementation functions +--! +--! Returns one row per violation found in the installed `eql_v3` surface. The +--! Postgres planner can only inline a function during index matching when: +--! +--! * `LANGUAGE sql` (plpgsql / C / etc. cannot be inlined) +--! * `IMMUTABLE` or `STABLE` volatility (VOLATILE cannot be inlined into +--! index expressions) +--! * No `SET` clauses (e.g. `SET search_path = ...`) +--! * Not `SECURITY DEFINER` +--! * Single-statement SELECT body +--! +--! @note The single-statement SELECT body condition is **not yet checked** by +--! this lint. A `LANGUAGE sql` function with a multi-statement body, a CTE, +--! or any pre-SELECT statement will pass all four implemented checks while +--! remaining non-inlinable. Implementing the check requires walking `prosrc` +--! (or `pg_get_functiondef`); tracked as a follow-up. +--! +--! Operators on `eql_v3` types (the jsonb-backed encrypted-domain families and +--! the SEM index-term type `eql_v3_internal.ore_block_256`) whose +--! implementation functions fail any of these rules silently fall back to seq +--! scan when the documented functional indexes (`eql_v3.eq_term(col)`, +--! `eql_v3.ord_term(col)`) are in place. This lint surfaces every such case. +--! +--! Severity: +--! `error` — fixable, blocks index matching, ship-blocking. +--! `warning` — likely-fixable, may not block matching but signals intent. +--! `info` — observational; useful for review, not a defect on its own. +--! +--! Categories: +--! `inlinability_language` — implementation function isn't `LANGUAGE sql`. +--! `inlinability_volatility` — implementation function is VOLATILE. +--! `inlinability_set_clause` — implementation function has a `SET` clause. +--! `inlinability_secdef` — implementation function is `SECURITY DEFINER`. +--! `inlinability_transitive` — implementation function is itself inlinable +--! but its body invokes a non-inlinable function +--! (depth 1; the planner can't peek through +--! that boundary). +--! `blocker_language` — encrypted-domain blocker is not LANGUAGE +--! plpgsql. The planner can inline / elide a +--! LANGUAGE sql body when the result is +--! provably unused, silently bypassing the +--! RAISE that the blocker exists to perform. +--! `blocker_strict` — encrypted-domain blocker is STRICT. +--! PostgreSQL skips the body and returns NULL +--! on NULL arguments, silently bypassing the +--! RAISE. +--! `domain_over_domain` — an `eql_v3` encrypted domain is derived from +--! another encrypted domain rather than jsonb. +--! Operators resolve against the ultimate base +--! type, so the derived domain does not +--! inherit the base domain's blocker surface. +--! `domain_opclass` — an operator class is declared FOR TYPE on an +--! `eql_v3` encrypted domain. Opclasses on +--! domains bypass operator resolution; use a +--! functional index on the extractor instead. +--! `schema_placement` — a naked composite or enum TYPE lives in the +--! public `eql_v3` schema. Internal index-term +--! types (e.g. `ore_block_256_term`) belong in +--! `eql_v3_internal`; a composite/enum in +--! `eql_v3` clutters the Supabase Table Builder +--! type picker, which the schema split exists to +--! prevent. Move it to `eql_v3_internal`. +--! +--! @example +--! ``` +--! SELECT severity, category, object_name, message +--! FROM eql_v3.lints() +--! WHERE severity = 'error' +--! ORDER BY category, object_name; +--! ``` +--! +--! @return SETOF record (severity text, category text, object_name text, message text) +CREATE OR REPLACE FUNCTION eql_v3.lints() +RETURNS TABLE ( + severity text, + category text, + object_name text, + message text +) +LANGUAGE sql STABLE +AS $$ + WITH + -- User-column encrypted domains now live in public so application tables + -- survive EQL uninstall. Keep this separate from owned_schemas(): public is + -- not installer-owned, but its EQL jsonb-backed domains are still the domain + -- types whose blockers/operator surfaces the lint must understand. + encrypted_domain_types AS ( + SELECT + dt.oid AS typid + FROM pg_catalog.pg_type dt + JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace + JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype + JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace + WHERE dt.typtype = 'd' + AND bt.typname = 'jsonb' + AND bn.nspname = 'pg_catalog' + AND ( + dn.nspname = 'public' + OR dn.nspname = ANY(eql_v3_internal.owned_schemas()) + ) + ), -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); + -- All operators where at least one operand is an EQL-owned type or a public + -- encrypted domain. Limits the scope of the lint to the operator surface + -- customers actually hit via SQL (`col = val`, `col @> '...'` and friends). + eql_operators AS ( + SELECT + op.oid AS oprid, + op.oprname AS opname, + op.oprcode AS implfunc, + op.oprleft::regtype AS lhs, + op.oprright::regtype AS rhs, + op.oprcode::regprocedure AS impl_signature + FROM pg_operator op + WHERE EXISTS ( + SELECT 1 FROM pg_type t + WHERE t.oid IN (op.oprleft, op.oprright) + AND ( + t.typnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY(eql_v3_internal.owned_schemas())) + OR t.oid IN (SELECT typid FROM encrypted_domain_types) + ) + ) + ), -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); + -- Cross-join with each operator's implementation function metadata. + -- One row per operator; columns describe the inlinability of the impl. + op_impl AS ( + SELECT + eo.opname, + eo.lhs, + eo.rhs, + eo.implfunc AS impl_oid, + eo.impl_signature::text AS impl_signature, + lang_l.lanname AS lang, + p.provolatile AS volatility, + p.proconfig AS config, + p.prosecdef AS secdef, + p.prosrc AS body + FROM eql_operators eo + JOIN pg_proc p ON p.oid = eo.implfunc + JOIN pg_language lang_l ON lang_l.oid = p.prolang + ), -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); + -- Encrypted-domain blockers: functions in `eql_v3` whose body contains + -- a blocker marker emitted by the codegen (any of the + -- `encrypted_domain_unsupported_*` helper calls — `_bool` for boolean + -- blockers, `_jsonb` for the native-jsonb-operator blockers; plus the + -- literal `is not supported for` for older path-operator blockers) AND + -- that take at least one encrypted domain over jsonb argument. The argument + -- filter excludes the shared `encrypted_domain_unsupported_*(text, text)` + -- helpers themselves, which contain the marker in their body but are not + -- blockers (they take text arguments, not a domain). + encrypted_domain_blockers AS ( + SELECT + p.oid AS oid, + p.oid::regprocedure::text AS signature, + lang_l.lanname AS lang, + p.proisstrict AS isstrict + FROM pg_catalog.pg_proc p + JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace + JOIN pg_catalog.pg_language lang_l ON lang_l.oid = p.prolang + WHERE n.nspname = ANY(eql_v3_internal.owned_schemas()) + AND (p.prosrc LIKE '%encrypted_domain_unsupported%' + OR p.prosrc LIKE '%is not supported for%') + AND EXISTS ( + SELECT 1 + FROM pg_catalog.unnest(p.proargtypes::oid[]) AS arg(typ) + JOIN encrypted_domain_types edt ON edt.typid = arg.typ + ) + ) -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ Direct inlinability checks: each row examines one operator's │ + -- │ implementation function and emits a violation if any rule is │ + -- │ broken. Multiple violations on the same function become │ + -- │ multiple rows (developers see every reason it doesn't inline). │ + -- └─────────────────────────────────────────────────────────────────┘ -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore -); + SELECT + 'error' AS severity, + 'inlinability_language' AS category, + format('operator %s(%s, %s) -> %s', + opname, lhs, rhs, impl_signature) AS object_name, + format( + '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.', + lang, opname) AS message + FROM op_impl + WHERE lang <> 'sql' + AND NOT EXISTS ( + SELECT 1 FROM encrypted_domain_blockers b + WHERE b.oid = op_impl.impl_oid + ) -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb -); + UNION ALL -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore -); + SELECT + 'error', + 'inlinability_volatility', + format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature), + format( + '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).', + opname) + FROM op_impl + WHERE volatility = 'v' + AND NOT EXISTS ( + SELECT 1 FROM encrypted_domain_blockers b + WHERE b.oid = op_impl.impl_oid + ) -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore -); + UNION ALL -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb -); + SELECT + 'error', + 'inlinability_set_clause', + format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature), + format( + '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.') + FROM op_impl + WHERE config IS NOT NULL + AND NOT EXISTS ( + SELECT 1 FROM encrypted_domain_blockers b + WHERE b.oid = op_impl.impl_oid + ) -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore -); + UNION ALL -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text -); + SELECT + 'error', + 'inlinability_secdef', + format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature), + 'Operator implementation function is `SECURITY DEFINER`. Such functions cannot be inlined; remove `SECURITY DEFINER` or use a non-inlinable wrapper layer.' + FROM op_impl + WHERE secdef + AND NOT EXISTS ( + SELECT 1 FROM encrypted_domain_blockers b + WHERE b.oid = op_impl.impl_oid + ) -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer -); + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ Transitive inlinability: an operator implementation function │ + -- │ that's itself inlinable can still fail to inline if its body │ + -- │ calls a non-inlinable function. Walk one level via pg_depend. │ + -- │ │ + -- │ Postgres records function-to-function dependencies in │ + -- │ pg_depend with deptype 'n' (normal) when one function references│ + -- │ another in its body — but only at CREATE time and only for │ + -- │ direct calls. This is good enough for v1; deeper transitive │ + -- │ analysis is a follow-up. │ + -- └─────────────────────────────────────────────────────────────────┘ -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore -); + UNION ALL -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text -); + SELECT + 'error', + 'inlinability_transitive', + format('operator %s(%s, %s) -> %s', oi.opname, oi.lhs, oi.rhs, + oi.impl_signature), + format( + '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.', + called.proname, + called_lang.lanname, + CASE called.provolatile + WHEN 'i' THEN 'IMMUTABLE' + WHEN 's' THEN 'STABLE' + WHEN 'v' THEN 'VOLATILE' + END, + CASE WHEN called.proconfig IS NOT NULL + THEN ', has SET clause' + ELSE '' END) + FROM op_impl oi + -- Only worth the transitive check if the outer function is otherwise + -- inlinable — otherwise the direct lints above already report it. + JOIN pg_proc outer_p ON outer_p.oid = oi.impl_signature::regprocedure + JOIN pg_depend d + ON d.classid = 'pg_proc'::regclass + AND d.objid = outer_p.oid + AND d.refclassid = 'pg_proc'::regclass + AND d.deptype = 'n' + JOIN pg_proc called ON called.oid = d.refobjid + JOIN pg_language called_lang ON called_lang.oid = called.prolang + WHERE oi.lang = 'sql' + AND oi.volatility IN ('i', 's') + AND oi.config IS NULL + AND NOT oi.secdef + AND called.oid <> outer_p.oid + AND ( + called_lang.lanname <> 'sql' + OR called.provolatile = 'v' + OR called.proconfig IS NOT NULL + OR called.prosecdef + ) -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer -); + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ Encrypted-domain footguns: blockers exist to RAISE, so they │ + -- │ have inverted inlinability requirements vs operator impls. │ + -- │ A LANGUAGE sql blocker can be elided by the planner; a STRICT │ + -- │ blocker returns NULL on NULL args. Both silently re-enable │ + -- │ operators the storage variant is supposed to block. │ + -- └─────────────────────────────────────────────────────────────────┘ -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore -); + UNION ALL -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text -); + SELECT + 'error', + 'blocker_language', + format('function %s', signature), + format( + '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.', + lang) + FROM encrypted_domain_blockers + WHERE lang <> 'plpgsql' -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[] -); + UNION ALL -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[] -); + SELECT + 'error', + 'blocker_strict', + format('function %s', signature), + 'Encrypted-domain blocker is `STRICT`. PostgreSQL skips the body and returns NULL on a NULL argument, silently bypassing the RAISE. Remove `STRICT`.' + FROM encrypted_domain_blockers + WHERE isstrict -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonpath -); + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ Domain identity: an encrypted-domain must be defined directly │ + -- │ over jsonb. Operators resolve against the ultimate base type, │ + -- │ so domain-over-domain inherits jsonb's operator surface and not │ + -- │ the base domain's blockers. │ + -- └─────────────────────────────────────────────────────────────────┘ -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonpath -); + UNION ALL -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[] -); + SELECT + 'error', + 'domain_over_domain', + format('domain %I.%I', dn.nspname, dt.typname), + format( + '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.', + dn.nspname, dt.typname, bn.nspname, bt.typname) + FROM pg_catalog.pg_type dt + JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace + JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype + JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace + WHERE dt.typtype = 'd' + AND dn.nspname = ANY(eql_v3_internal.owned_schemas()) + AND bt.typtype = 'd' + AND bt.oid IN (SELECT typid FROM encrypted_domain_types) -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[] -); + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ Domain opclass: an operator class declared FOR TYPE on an │ + -- │ encrypted-domain bypasses operator resolution at index time. │ + -- │ Use a functional index on the extractor instead. │ + -- └─────────────────────────────────────────────────────────────────┘ -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text -); + UNION ALL -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer -); + SELECT + 'error', + 'domain_opclass', + format('opclass %I.%I FOR TYPE %s.%s', cn.nspname, oc.opcname, tn.nspname, t.typname), + format( + '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.', + cn.nspname, oc.opcname, tn.nspname, t.typname, tn.nspname, tn.nspname) + FROM pg_catalog.pg_opclass oc + JOIN pg_catalog.pg_type t ON t.oid = oc.opcintype + JOIN pg_catalog.pg_namespace tn ON tn.oid = t.typnamespace + JOIN pg_catalog.pg_namespace cn ON cn.oid = oc.opcnamespace + WHERE t.oid IN (SELECT typid FROM encrypted_domain_types) -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[] -); + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ Schema placement: the public `eql_v3` schema must hold only the │ + -- │ jsonb-backed encrypted-domain types. A naked composite/enum type │ + -- │ there is an internal index-term type in the wrong schema — it │ + -- │ clutters the Supabase type picker the split exists to keep clean. │ + -- └─────────────────────────────────────────────────────────────────┘ -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[] -); + UNION ALL -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore -); + SELECT + 'error', + 'schema_placement', + format('type %I.%I', n.nspname, t.typname), + format( + '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.nspname, t.typname, + CASE t.typtype WHEN 'c' THEN 'composite type' WHEN 'e' THEN 'enum type' ELSE 'type' END) + FROM pg_catalog.pg_type t + JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace + WHERE n.nspname = 'eql_v3' + AND t.typtype IN ('c', 'e') -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb -); + ORDER BY 1, 2, 3; +$$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore -); +COMMENT ON FUNCTION eql_v3.lints() IS + 'EQL lint: returns one row per non-inlinable operator implementation. ' + 'Run `SELECT * FROM eql_v3.lints() WHERE severity = ''error''` for a ' + 'CI-gateable check that all operator implementations on eql_v3 types are ' + 'eligible for planner inlining.'; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/real_ord_ope_operators.sql ---! @brief Operators for public.eql_v3_real_ord_ope. +--! @file encrypted_domain/bigint/bigint_operators.sql +--! @brief Operators for public.eql_v3_bigint. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope + LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb + LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope + LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb + LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_bigint, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer + LEFTARG = public.eql_v3_bigint, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_bigint, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer + LEFTARG = public.eql_v3_bigint, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_bigint, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_bigint, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_bigint, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_bigint, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_bigint, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_bigint, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer + LEFTARG = public.eql_v3_bigint, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_bigint, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_bigint, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope + LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb + LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/real_ord_operators.sql ---! @brief Operators for public.eql_v3_real_ord. +--! @file encrypted_domain/bigint/bigint_eq_functions.sql +--! @brief Functions for public.eql_v3_bigint_eq. -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Index extractor for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_bigint_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_bigint_eq) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_bigint_eq. +--! @param a jsonb +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) = eql_v3.eq_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_bigint_eq) $$; + +--! @brief Operator wrapper for public.eql_v3_bigint_eq. +--! @param a jsonb +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a jsonb +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a jsonb +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a jsonb +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a jsonb +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a jsonb +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a jsonb +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param selector text +--! @return public.eql_v3_bigint_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_eq, selector text) +RETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param selector integer +--! @return public.eql_v3_bigint_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_eq, selector integer) +RETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a jsonb +--! @param selector public.eql_v3_bigint_eq +--! @return public.eql_v3_bigint_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_eq) +RETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a jsonb +--! @param selector public.eql_v3_bigint_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a jsonb +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b public.eql_v3_bigint_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a jsonb +--! @param b public.eql_v3_bigint_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = text -); +--! @file encrypted_domain/bigint/query_bigint_ord_ore_functions.sql +--! @brief Functions for eql_v3.query_bigint_ord_ore. -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer -); +--! @brief Index extractor for eql_v3.query_bigint_ord_ore. +--! @param a eql_v3.query_bigint_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_bigint_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord -); +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b eql_v3.query_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = text -); +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. +--! @param a eql_v3.query_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer -); +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b eql_v3.query_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord -); +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. +--! @param a eql_v3.query_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = text -); +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b eql_v3.query_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. +--! @param a eql_v3.query_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b eql_v3.query_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonpath -); +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. +--! @param a eql_v3.query_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonpath -); +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b eql_v3.query_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. +--! @param a eql_v3.query_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b eql_v3.query_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = text -); +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. +--! @param a eql_v3.query_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer -); +--! @file encrypted_domain/bigint/query_bigint_eq_functions.sql +--! @brief Functions for eql_v3.query_bigint_eq. -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[] -); +--! @brief Index extractor for eql_v3.query_bigint_eq. +--! @param a eql_v3.query_bigint_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_bigint_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b eql_v3.query_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b eql_v3.query_bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord -); +--! @brief Operator wrapper for eql_v3.query_bigint_eq. +--! @param a eql_v3.query_bigint_eq +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_eq, b public.eql_v3_bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb -); +--! @brief Operator wrapper for eql_v3.query_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b eql_v3.query_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b eql_v3.query_bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord -); +--! @brief Operator wrapper for eql_v3.query_bigint_eq. +--! @param a eql_v3.query_bigint_eq +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_eq, b public.eql_v3_bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/real_functions.sql ---! @brief Functions for public.eql_v3_real. +--! @file encrypted_domain/bigint/bigint_ord_ope_functions.sql +--! @brief Functions for public.eql_v3_bigint_ord_ope. ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real +--! @brief Index extractor for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_bigint_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b public.eql_v3_real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) = eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b public.eql_v3_real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) <> eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b public.eql_v3_real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b public.eql_v3_real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b public.eql_v3_real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b public.eql_v3_real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b public.eql_v3_real) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b public.eql_v3_real) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param selector text ---! @return public.eql_v3_real -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real, selector text) -RETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$ +--! @return public.eql_v3_bigint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ope, selector text) +RETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param selector integer ---! @return public.eql_v3_real -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real, selector integer) -RETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$ +--! @return public.eql_v3_bigint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ope, selector integer) +RETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. --! @param a jsonb ---! @param selector public.eql_v3_real ---! @return public.eql_v3_real -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real) -RETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$ +--! @param selector public.eql_v3_bigint_ord_ope +--! @return public.eql_v3_bigint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_ord_ope) +RETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. --! @param a jsonb ---! @param selector public.eql_v3_real +--! @param selector public.eql_v3_bigint_ord_ope --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_bigint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real, b public.eql_v3_real) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real +--! @param b public.eql_v3_bigint_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/query_real_ord_ore_functions.sql ---! @brief Functions for eql_v3.query_real_ord_ore. - ---! @brief Index extractor for eql_v3.query_real_ord_ore. ---! @param a eql_v3.query_real_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_real_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.query_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b eql_v3.query_real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_real_ord_ore. ---! @param a eql_v3.query_real_ord_ore ---! @param b public.eql_v3_real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b eql_v3.query_real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +--! @file encrypted_domain/bigint/bigint_ord_ore_aggregates.sql +--! @brief Aggregates for public.eql_v3_bigint_ord_ore. ---! @brief Operator wrapper for eql_v3.query_real_ord_ore. ---! @param a eql_v3.query_real_ord_ore ---! @param b public.eql_v3_real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +--! @brief State function for min on public.eql_v3_bigint_ord_ore. +--! @param state public.eql_v3_bigint_ord_ore +--! @param value public.eql_v3_bigint_ord_ore +--! @return public.eql_v3_bigint_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord_ore, value public.eql_v3_bigint_ord_ore) +RETURNS public.eql_v3_bigint_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Operator wrapper for eql_v3.query_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b eql_v3.query_real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +--! @brief min aggregate for public.eql_v3_bigint_ord_ore. +--! @param input public.eql_v3_bigint_ord_ore +--! @return public.eql_v3_bigint_ord_ore +CREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_bigint_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); ---! @brief Operator wrapper for eql_v3.query_real_ord_ore. ---! @param a eql_v3.query_real_ord_ore ---! @param b public.eql_v3_real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +--! @brief State function for max on public.eql_v3_bigint_ord_ore. +--! @param state public.eql_v3_bigint_ord_ore +--! @param value public.eql_v3_bigint_ord_ore +--! @return public.eql_v3_bigint_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord_ore, value public.eql_v3_bigint_ord_ore) +RETURNS public.eql_v3_bigint_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Operator wrapper for eql_v3.query_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b eql_v3.query_real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +--! @brief max aggregate for public.eql_v3_bigint_ord_ore. +--! @param input public.eql_v3_bigint_ord_ore +--! @return public.eql_v3_bigint_ord_ore +CREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_bigint_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Operator wrapper for eql_v3.query_real_ord_ore. ---! @param a eql_v3.query_real_ord_ore ---! @param b public.eql_v3_real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +--! @file encrypted_domain/bigint/bigint_ord_aggregates.sql +--! @brief Aggregates for public.eql_v3_bigint_ord. ---! @brief Operator wrapper for eql_v3.query_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b eql_v3.query_real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +--! @brief State function for min on public.eql_v3_bigint_ord. +--! @param state public.eql_v3_bigint_ord +--! @param value public.eql_v3_bigint_ord +--! @return public.eql_v3_bigint_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord, value public.eql_v3_bigint_ord) +RETURNS public.eql_v3_bigint_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Operator wrapper for eql_v3.query_real_ord_ore. ---! @param a eql_v3.query_real_ord_ore ---! @param b public.eql_v3_real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +--! @brief min aggregate for public.eql_v3_bigint_ord. +--! @param input public.eql_v3_bigint_ord +--! @return public.eql_v3_bigint_ord +CREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_bigint_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); ---! @brief Operator wrapper for eql_v3.query_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b eql_v3.query_real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +--! @brief State function for max on public.eql_v3_bigint_ord. +--! @param state public.eql_v3_bigint_ord +--! @param value public.eql_v3_bigint_ord +--! @return public.eql_v3_bigint_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord, value public.eql_v3_bigint_ord) +RETURNS public.eql_v3_bigint_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Operator wrapper for eql_v3.query_real_ord_ore. ---! @param a eql_v3.query_real_ord_ore ---! @param b public.eql_v3_real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +--! @brief max aggregate for public.eql_v3_bigint_ord. +--! @param input public.eql_v3_bigint_ord +--! @return public.eql_v3_bigint_ord +CREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_bigint_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/query_real_ord_functions.sql ---! @brief Functions for eql_v3.query_real_ord. +--! @file encrypted_domain/bigint/query_bigint_ord_ope_functions.sql +--! @brief Functions for eql_v3.query_bigint_ord_ope. ---! @brief Index extractor for eql_v3.query_real_ord. ---! @param a eql_v3.query_real_ord +--! @brief Index extractor for eql_v3.query_bigint_ord_ope. +--! @param a eql_v3.query_bigint_ord_ope --! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_real_ord) +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_bigint_ord_ope) RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b eql_v3.query_real_ord +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b eql_v3.query_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b eql_v3.query_real_ord) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord. ---! @param a eql_v3.query_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. +--! @param a eql_v3.query_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b eql_v3.query_real_ord +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b eql_v3.query_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b eql_v3.query_real_ord) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord. ---! @param a eql_v3.query_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. +--! @param a eql_v3.query_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b eql_v3.query_real_ord +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b eql_v3.query_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b eql_v3.query_real_ord) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord. ---! @param a eql_v3.query_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. +--! @param a eql_v3.query_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b eql_v3.query_real_ord +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b eql_v3.query_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b eql_v3.query_real_ord) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord. ---! @param a eql_v3.query_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. +--! @param a eql_v3.query_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b eql_v3.query_real_ord +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b eql_v3.query_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b eql_v3.query_real_ord) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord. ---! @param a eql_v3.query_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. +--! @param a eql_v3.query_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b eql_v3.query_real_ord +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b eql_v3.query_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b eql_v3.query_real_ord) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord. ---! @param a eql_v3.query_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. +--! @param a eql_v3.query_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/query_real_ord_ope_functions.sql ---! @brief Functions for eql_v3.query_real_ord_ope. - ---! @brief Index extractor for eql_v3.query_real_ord_ope. ---! @param a eql_v3.query_real_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_real_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +--! @file encrypted_domain/bigint/query_bigint_ord_operators.sql +--! @brief Operators for eql_v3.query_bigint_ord. ---! @brief Operator wrapper for eql_v3.query_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b eql_v3.query_real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_real_ord_ope. ---! @param a eql_v3.query_real_ord_ope ---! @param b public.eql_v3_real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b eql_v3.query_real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_real_ord_ope. ---! @param a eql_v3.query_real_ord_ope ---! @param b public.eql_v3_real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b eql_v3.query_real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for eql_v3.query_real_ord_ope. ---! @param a eql_v3.query_real_ord_ope ---! @param b public.eql_v3_real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for eql_v3.query_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b eql_v3.query_real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for eql_v3.query_real_ord_ope. ---! @param a eql_v3.query_real_ord_ope ---! @param b public.eql_v3_real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for eql_v3.query_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b eql_v3.query_real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for eql_v3.query_real_ord_ope. ---! @param a eql_v3.query_real_ord_ope ---! @param b public.eql_v3_real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for eql_v3.query_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b eql_v3.query_real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for eql_v3.query_real_ord_ope. ---! @param a eql_v3.query_real_ord_ope ---! @param b public.eql_v3_real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/query_real_eq_functions.sql ---! @brief Functions for eql_v3.query_real_eq. +--! @file encrypted_domain/bigint/bigint_ord_ope_operators.sql +--! @brief Operators for public.eql_v3_bigint_ord_ope. ---! @brief Index extractor for eql_v3.query_real_eq. ---! @param a eql_v3.query_real_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_real_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b eql_v3.query_real_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b eql_v3.query_real_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_real_eq. ---! @param a eql_v3.query_real_eq ---! @param b public.eql_v3_real_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_real_eq, b public.eql_v3_real_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b eql_v3.query_real_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b eql_v3.query_real_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_real_eq. ---! @param a eql_v3.query_real_eq ---! @param b public.eql_v3_real_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_real_eq, b public.eql_v3_real_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @file v3/sem/ore_block_256/operator_class.sql ---! @brief B-tree operator family + default class on eql_v3_internal.ore_block_256. ---! ---! Gives the composite type its DEFAULT btree opclass so the recommended ---! functional index `CREATE INDEX ON t (eql_v3.ord_term_ore(col))` engages without ---! an explicit opclass annotation (design D4). ---! ---! @note Creating an operator family/class requires superuser: Postgres forbids ---! CREATE OPERATOR FAMILY / CLASS to non-superusers to protect index ---! integrity. Managed platforms (Supabase, and most hosted Postgres) run ---! the installer as a non-superuser role, so the DO block below ATTEMPTS ---! the creation and skips it on insufficient_privilege (SQLSTATE 42501), ---! letting the single installer run everywhere. When the class is absent, ---! ORE ordered scans over eql_v3_internal.ore_block_256 are unavailable, ---! but the order-preserving (OPE) ordering domains — whose extractor ---! return types carry a native btree opclass — still index without it. On ---! superuser installs (self-managed Postgres, the SQLx test matrix) the ---! class is created normally. Any non-privilege error still propagates. ---! @see eql_v3_internal.compare_ore_block_256_terms +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); -DO $do$ -BEGIN - EXECUTE 'CREATE OPERATOR FAMILY eql_v3_internal.ore_block_256_operator_family USING btree'; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); - EXECUTE $ddl$ - CREATE OPERATOR CLASS eql_v3_internal.ore_block_256_operator_class - DEFAULT FOR TYPE eql_v3_internal.ore_block_256 - USING btree FAMILY eql_v3_internal.ore_block_256_operator_family AS - OPERATOR 1 public.<, - OPERATOR 2 public.<=, - OPERATOR 3 public.=, - OPERATOR 4 public.>=, - OPERATOR 5 public.>, - FUNCTION 1 eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) - $ddl$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); - RAISE NOTICE 'EQL: created btree operator class eql_v3_internal.ore_block_256_operator_class'; -EXCEPTION - WHEN insufficient_privilege THEN - 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'; -END; -$do$; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @file encrypted_domain/numeric/query_numeric_ord_ore_functions.sql ---! @brief Functions for eql_v3.query_numeric_ord_ore. +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Index extractor for eql_v3.query_numeric_ord_ore. ---! @param a eql_v3.query_numeric_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_numeric_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b eql_v3.query_numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. ---! @param a eql_v3.query_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b eql_v3.query_numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. ---! @param a eql_v3.query_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b eql_v3.query_numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. ---! @param a eql_v3.query_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b eql_v3.query_numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. ---! @param a eql_v3.query_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b eql_v3.query_numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. ---! @param a eql_v3.query_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b eql_v3.query_numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. ---! @param a eql_v3.query_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer +); ---! @file encrypted_domain/numeric/query_numeric_ord_functions.sql ---! @brief Functions for eql_v3.query_numeric_ord. +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope +); ---! @brief Index extractor for eql_v3.query_numeric_ord. ---! @param a eql_v3.query_numeric_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_numeric_ord) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b eql_v3.query_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord. ---! @param a eql_v3.query_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b eql_v3.query_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonpath +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord. ---! @param a eql_v3.query_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b eql_v3.query_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord. ---! @param a eql_v3.query_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b eql_v3.query_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonpath +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord. ---! @param a eql_v3.query_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b eql_v3.query_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord. ---! @param a eql_v3.query_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b eql_v3.query_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord. ---! @param a eql_v3.query_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[] +); ---! @file encrypted_domain/numeric/query_numeric_ord_ope_functions.sql ---! @brief Functions for eql_v3.query_numeric_ord_ope. +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[] +); ---! @brief Index extractor for eql_v3.query_numeric_ord_ope. ---! @param a eql_v3.query_numeric_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_numeric_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b eql_v3.query_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. ---! @param a eql_v3.query_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b eql_v3.query_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +--! @file encrypted_domain/bigint/query_bigint_eq_operators.sql +--! @brief Operators for eql_v3.query_bigint_eq. ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. ---! @param a eql_v3.query_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = eql_v3.query_bigint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b eql_v3.query_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. ---! @param a eql_v3.query_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = eql_v3.query_bigint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b eql_v3.query_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. ---! @param a eql_v3.query_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +--! @file encrypted_domain/bigint/query_bigint_ord_ore_operators.sql +--! @brief Operators for eql_v3.query_bigint_ord_ore. ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b eql_v3.query_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. ---! @param a eql_v3.query_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b eql_v3.query_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. ---! @param a eql_v3.query_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @file encrypted_domain/numeric/query_numeric_eq_functions.sql ---! @brief Functions for eql_v3.query_numeric_eq. +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Index extractor for eql_v3.query_numeric_eq. ---! @param a eql_v3.query_numeric_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_numeric_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for eql_v3.query_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b eql_v3.query_numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b eql_v3.query_numeric_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for eql_v3.query_numeric_eq. ---! @param a eql_v3.query_numeric_eq ---! @param b public.eql_v3_numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_eq, b public.eql_v3_numeric_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for eql_v3.query_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b eql_v3.query_numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b eql_v3.query_numeric_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for eql_v3.query_numeric_eq. ---! @param a eql_v3.query_numeric_eq ---! @param b public.eql_v3_numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_eq, b public.eql_v3_numeric_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/numeric/numeric_ord_ore_operators.sql ---! @brief Operators for public.eql_v3_numeric_ord_ore. +--! @file encrypted_domain/bigint/bigint_eq_operators.sql +--! @brief Operators for public.eql_v3_bigint_eq. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/numeric/numeric_ord_ope_operators.sql ---! @brief Operators for public.eql_v3_numeric_ord_ope. +--! @file encrypted_domain/bigint/bigint_ord_ope_aggregates.sql +--! @brief Aggregates for public.eql_v3_bigint_ord_ope. + +--! @brief State function for min on public.eql_v3_bigint_ord_ope. +--! @param state public.eql_v3_bigint_ord_ope +--! @param value public.eql_v3_bigint_ord_ope +--! @return public.eql_v3_bigint_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord_ope, value public.eql_v3_bigint_ord_ope) +RETURNS public.eql_v3_bigint_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.eql_v3_bigint_ord_ope. +--! @param input public.eql_v3_bigint_ord_ope +--! @return public.eql_v3_bigint_ord_ope +CREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_bigint_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.eql_v3_bigint_ord_ope. +--! @param state public.eql_v3_bigint_ord_ope +--! @param value public.eql_v3_bigint_ord_ope +--! @return public.eql_v3_bigint_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord_ope, value public.eql_v3_bigint_ord_ope) +RETURNS public.eql_v3_bigint_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.eql_v3_bigint_ord_ope. +--! @param input public.eql_v3_bigint_ord_ope +--! @return public.eql_v3_bigint_ord_ope +CREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_bigint_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/query_bigint_ord_ope_operators.sql +--! @brief Operators for eql_v3.query_bigint_ord_ope. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb, + LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/query_real_ord_ore_operators.sql +--! @brief Operators for eql_v3.query_real_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope, + LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb, + LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ore_operators.sql +--! @brief Operators for public.eql_v3_real_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/numeric/numeric_ord_operators.sql ---! @brief Operators for public.eql_v3_numeric_ord. +--! @file encrypted_domain/real/real_ord_operators.sql +--! @brief Operators for public.eql_v3_real_ord. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord + LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord + LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text + LEFTARG = public.eql_v3_real_ord, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text + LEFTARG = public.eql_v3_real_ord, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text + LEFTARG = public.eql_v3_real_ord, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_functions.sql ---! @brief Functions for public.eql_v3_numeric. - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b public.eql_v3_numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b public.eql_v3_numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b public.eql_v3_numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b public.eql_v3_numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b public.eql_v3_numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b public.eql_v3_numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b public.eql_v3_numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b public.eql_v3_numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param selector text ---! @return public.eql_v3_numeric -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric, selector text) -RETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param selector integer ---! @return public.eql_v3_numeric -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric, selector integer) -RETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param selector public.eql_v3_numeric ---! @return public.eql_v3_numeric -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric) -RETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param selector public.eql_v3_numeric ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric, b public.eql_v3_numeric) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/integer/query_integer_ord_ore_functions.sql ---! @brief Functions for eql_v3.query_integer_ord_ore. - ---! @brief Index extractor for eql_v3.query_integer_ord_ore. ---! @param a eql_v3.query_integer_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_integer_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonpath +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b eql_v3.query_integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ore. ---! @param a eql_v3.query_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b eql_v3.query_integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ore. ---! @param a eql_v3.query_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonpath +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b eql_v3.query_integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ore. ---! @param a eql_v3.query_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b eql_v3.query_integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_real_ord, RIGHTARG = text +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ore. ---! @param a eql_v3.query_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b eql_v3.query_integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ore. ---! @param a eql_v3.query_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b eql_v3.query_integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ore. ---! @param a eql_v3.query_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord +); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/integer/query_integer_ord_functions.sql ---! @brief Functions for eql_v3.query_integer_ord. +--! @file encrypted_domain/real/query_real_ord_functions.sql +--! @brief Functions for eql_v3.query_real_ord. ---! @brief Index extractor for eql_v3.query_integer_ord. ---! @param a eql_v3.query_integer_ord +--! @brief Index extractor for eql_v3.query_real_ord. +--! @param a eql_v3.query_real_ord --! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_integer_ord) +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_real_ord) RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b eql_v3.query_integer_ord +--! @brief Operator wrapper for eql_v3.query_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b eql_v3.query_real_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b eql_v3.query_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord. ---! @param a eql_v3.query_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for eql_v3.query_real_ord. +--! @param a eql_v3.query_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b eql_v3.query_integer_ord +--! @brief Operator wrapper for eql_v3.query_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b eql_v3.query_real_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b eql_v3.query_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord. ---! @param a eql_v3.query_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for eql_v3.query_real_ord. +--! @param a eql_v3.query_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b eql_v3.query_integer_ord +--! @brief Operator wrapper for eql_v3.query_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b eql_v3.query_real_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b eql_v3.query_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord. ---! @param a eql_v3.query_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for eql_v3.query_real_ord. +--! @param a eql_v3.query_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b eql_v3.query_integer_ord +--! @brief Operator wrapper for eql_v3.query_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b eql_v3.query_real_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b eql_v3.query_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord. ---! @param a eql_v3.query_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for eql_v3.query_real_ord. +--! @param a eql_v3.query_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b eql_v3.query_integer_ord +--! @brief Operator wrapper for eql_v3.query_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b eql_v3.query_real_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b eql_v3.query_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord. ---! @param a eql_v3.query_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for eql_v3.query_real_ord. +--! @param a eql_v3.query_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b eql_v3.query_integer_ord +--! @brief Operator wrapper for eql_v3.query_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b eql_v3.query_real_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b eql_v3.query_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord. ---! @param a eql_v3.query_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for eql_v3.query_real_ord. +--! @param a eql_v3.query_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/integer/query_integer_ord_ope_functions.sql ---! @brief Functions for eql_v3.query_integer_ord_ope. +--! @file encrypted_domain/real/real_ord_ore_aggregates.sql +--! @brief Aggregates for public.eql_v3_real_ord_ore. ---! @brief Index extractor for eql_v3.query_integer_ord_ope. ---! @param a eql_v3.query_integer_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_integer_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +--! @brief State function for min on public.eql_v3_real_ord_ore. +--! @param state public.eql_v3_real_ord_ore +--! @param value public.eql_v3_real_ord_ore +--! @return public.eql_v3_real_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord_ore, value public.eql_v3_real_ord_ore) +RETURNS public.eql_v3_real_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Operator wrapper for eql_v3.query_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b eql_v3.query_integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +--! @brief min aggregate for public.eql_v3_real_ord_ore. +--! @param input public.eql_v3_real_ord_ore +--! @return public.eql_v3_real_ord_ore +CREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_real_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ope. ---! @param a eql_v3.query_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +--! @brief State function for max on public.eql_v3_real_ord_ore. +--! @param state public.eql_v3_real_ord_ore +--! @param value public.eql_v3_real_ord_ore +--! @return public.eql_v3_real_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord_ore, value public.eql_v3_real_ord_ore) +RETURNS public.eql_v3_real_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Operator wrapper for eql_v3.query_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b eql_v3.query_integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +--! @brief max aggregate for public.eql_v3_real_ord_ore. +--! @param input public.eql_v3_real_ord_ore +--! @return public.eql_v3_real_ord_ore +CREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_real_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Operator wrapper for eql_v3.query_integer_ord_ope. ---! @param a eql_v3.query_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +--! @file encrypted_domain/real/real_ord_ope_operators.sql +--! @brief Operators for public.eql_v3_real_ord_ope. ---! @brief Operator wrapper for eql_v3.query_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b eql_v3.query_integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ope. ---! @param a eql_v3.query_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b eql_v3.query_integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ope. ---! @param a eql_v3.query_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonpath +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b eql_v3.query_integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ope. ---! @param a eql_v3.query_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b eql_v3.query_integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ope. ---! @param a eql_v3.query_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonpath +); ---! @file encrypted_domain/integer/query_integer_eq_functions.sql ---! @brief Functions for eql_v3.query_integer_eq. +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[] +); ---! @brief Index extractor for eql_v3.query_integer_eq. ---! @param a eql_v3.query_integer_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_integer_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b eql_v3.query_integer_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b eql_v3.query_integer_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text +); ---! @brief Operator wrapper for eql_v3.query_integer_eq. ---! @param a eql_v3.query_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_eq, b public.eql_v3_integer_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer +); ---! @brief Operator wrapper for eql_v3.query_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b eql_v3.query_integer_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b eql_v3.query_integer_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_integer_eq. ---! @param a eql_v3.query_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_eq, b public.eql_v3_integer_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[] +); ---! @file encrypted_domain/integer/integer_ord_ore_operators.sql ---! @brief Operators for public.eql_v3_integer_ord_ore. +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope +); -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope ); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/query_real_eq_operators.sql +--! @brief Operators for eql_v3.query_real_eq. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = eql_v3.query_real_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore, + LEFTARG = eql_v3.query_real_eq, RIGHTARG = public.eql_v3_real_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = eql_v3.query_real_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb, + LEFTARG = eql_v3.query_real_eq, RIGHTARG = public.eql_v3_real_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/query_real_ord_ope_operators.sql +--! @brief Operators for eql_v3.query_real_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore, + LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore, + LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore, + LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb, + LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @file encrypted_domain/real/real_functions.sql +--! @brief Functions for public.eql_v3_real. -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b public.eql_v3_real +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a jsonb +--! @param b public.eql_v3_real +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b public.eql_v3_real +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a jsonb +--! @param b public.eql_v3_real +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b public.eql_v3_real +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a jsonb +--! @param b public.eql_v3_real +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b public.eql_v3_real +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a jsonb +--! @param b public.eql_v3_real +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b public.eql_v3_real +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a jsonb +--! @param b public.eql_v3_real +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b public.eql_v3_real +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a jsonb +--! @param b public.eql_v3_real +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b public.eql_v3_real +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a jsonb +--! @param b public.eql_v3_real +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b public.eql_v3_real +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a jsonb +--! @param b public.eql_v3_real +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param selector text +--! @return public.eql_v3_real +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real, selector text) +RETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param selector integer +--! @return public.eql_v3_real +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real, selector integer) +RETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a jsonb +--! @param selector public.eql_v3_real +--! @return public.eql_v3_real +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real) +RETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a jsonb +--! @param selector public.eql_v3_real +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b public.eql_v3_real +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a jsonb +--! @param b public.eql_v3_real +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b public.eql_v3_real +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real, b public.eql_v3_real) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a jsonb +--! @param b public.eql_v3_real +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[] -); +--! @file encrypted_domain/real/real_ord_aggregates.sql +--! @brief Aggregates for public.eql_v3_real_ord. -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[] -); +--! @brief State function for min on public.eql_v3_real_ord. +--! @param state public.eql_v3_real_ord +--! @param value public.eql_v3_real_ord +--! @return public.eql_v3_real_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord, value public.eql_v3_real_ord) +RETURNS public.eql_v3_real_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore +--! @brief min aggregate for public.eql_v3_real_ord. +--! @param input public.eql_v3_real_ord +--! @return public.eql_v3_real_ord +CREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_real_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe ); -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb -); +--! @brief State function for max on public.eql_v3_real_ord. +--! @param state public.eql_v3_real_ord +--! @param value public.eql_v3_real_ord +--! @return public.eql_v3_real_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord, value public.eql_v3_real_ord) +RETURNS public.eql_v3_real_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore +--! @brief max aggregate for public.eql_v3_real_ord. +--! @param input public.eql_v3_real_ord +--! @return public.eql_v3_real_ord +CREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_real_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/integer/integer_ord_ope_operators.sql ---! @brief Operators for public.eql_v3_integer_ord_ope. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @file encrypted_domain/real/query_real_ord_operators.sql +--! @brief Operators for eql_v3.query_real_ord. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope, + LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope, + LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope, + LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope, + LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope, + LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope, + LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope -); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/integer/integer_ord_operators.sql ---! @brief Operators for public.eql_v3_integer_ord. +--! @file encrypted_domain/real/real_operators.sql +--! @brief Operators for public.eql_v3_real. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.eql_v3_real, RIGHTARG = jsonb ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.eql_v3_real, RIGHTARG = jsonb ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_real, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_real, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_real, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_real, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord + LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord + LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text + LEFTARG = public.eql_v3_real, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_real, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text + LEFTARG = public.eql_v3_real, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_real, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text + LEFTARG = public.eql_v3_real, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_real, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_real, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_real, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_real, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_real, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_real, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_real, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text + LEFTARG = public.eql_v3_real, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_real, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_real, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_real, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord + LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/integer/integer_functions.sql ---! @brief Functions for public.eql_v3_integer. - ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b public.eql_v3_integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/real/real_ord_ope_aggregates.sql +--! @brief Aggregates for public.eql_v3_real_ord_ope. ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b public.eql_v3_integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +--! @brief State function for min on public.eql_v3_real_ord_ope. +--! @param state public.eql_v3_real_ord_ope +--! @param value public.eql_v3_real_ord_ope +--! @return public.eql_v3_real_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord_ope, value public.eql_v3_real_ord_ope) +RETURNS public.eql_v3_real_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +--! @brief min aggregate for public.eql_v3_real_ord_ope. +--! @param input public.eql_v3_real_ord_ope +--! @return public.eql_v3_real_ord_ope +CREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_real_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +--! @brief State function for max on public.eql_v3_real_ord_ope. +--! @param state public.eql_v3_real_ord_ope +--! @param value public.eql_v3_real_ord_ope +--! @return public.eql_v3_real_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord_ope, value public.eql_v3_real_ord_ope) +RETURNS public.eql_v3_real_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b public.eql_v3_integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +--! @brief max aggregate for public.eql_v3_real_ord_ope. +--! @param input public.eql_v3_real_ord_ope +--! @return public.eql_v3_real_ord_ope +CREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_real_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/real/real_eq_operators.sql +--! @brief Operators for public.eql_v3_real_eq. ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b public.eql_v3_integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b public.eql_v3_integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b public.eql_v3_integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b public.eql_v3_integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b public.eql_v3_integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param selector text ---! @return public.eql_v3_integer -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer, selector text) -RETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param selector integer ---! @return public.eql_v3_integer -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer, selector integer) -RETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param selector public.eql_v3_integer ---! @return public.eql_v3_integer -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer) -RETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param selector public.eql_v3_integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer, b public.eql_v3_integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonpath +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb +); ---! @file encrypted_domain/double/query_double_ord_ore_functions.sql ---! @brief Functions for eql_v3.query_double_ord_ore. +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq +); ---! @brief Index extractor for eql_v3.query_double_ord_ore. ---! @param a eql_v3.query_double_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_double_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonpath +); ---! @brief Operator wrapper for eql_v3.query_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b eql_v3.query_double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_double_ord_ore. ---! @param a eql_v3.query_double_ord_ore ---! @param b public.eql_v3_double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b eql_v3.query_double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = text +); ---! @brief Operator wrapper for eql_v3.query_double_ord_ore. ---! @param a eql_v3.query_double_ord_ore ---! @param b public.eql_v3_double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer +); ---! @brief Operator wrapper for eql_v3.query_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b eql_v3.query_double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_double_ord_ore. ---! @param a eql_v3.query_double_ord_ore ---! @param b public.eql_v3_double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b eql_v3.query_double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq +); ---! @brief Operator wrapper for eql_v3.query_double_ord_ore. ---! @param a eql_v3.query_double_ord_ore ---! @param b public.eql_v3_double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb +); ---! @brief Operator wrapper for eql_v3.query_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b eql_v3.query_double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Operator wrapper for eql_v3.query_double_ord_ore. ---! @param a eql_v3.query_double_ord_ore ---! @param b public.eql_v3_double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +--! @file encrypted_domain/smallint/smallint_ord_ore_aggregates.sql +--! @brief Aggregates for public.eql_v3_smallint_ord_ore. ---! @brief Operator wrapper for eql_v3.query_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b eql_v3.query_double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +--! @brief State function for min on public.eql_v3_smallint_ord_ore. +--! @param state public.eql_v3_smallint_ord_ore +--! @param value public.eql_v3_smallint_ord_ore +--! @return public.eql_v3_smallint_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord_ore, value public.eql_v3_smallint_ord_ore) +RETURNS public.eql_v3_smallint_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ore. ---! @param a eql_v3.query_double_ord_ore ---! @param b public.eql_v3_double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +--! @brief min aggregate for public.eql_v3_smallint_ord_ore. +--! @param input public.eql_v3_smallint_ord_ore +--! @return public.eql_v3_smallint_ord_ore +CREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_smallint_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.eql_v3_smallint_ord_ore. +--! @param state public.eql_v3_smallint_ord_ore +--! @param value public.eql_v3_smallint_ord_ore +--! @return public.eql_v3_smallint_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord_ore, value public.eql_v3_smallint_ord_ore) +RETURNS public.eql_v3_smallint_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.eql_v3_smallint_ord_ore. +--! @param input public.eql_v3_smallint_ord_ore +--! @return public.eql_v3_smallint_ord_ore +CREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_smallint_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/query_double_ord_functions.sql ---! @brief Functions for eql_v3.query_double_ord. +--! @file encrypted_domain/smallint/query_smallint_ord_ope_functions.sql +--! @brief Functions for eql_v3.query_smallint_ord_ope. ---! @brief Index extractor for eql_v3.query_double_ord. ---! @param a eql_v3.query_double_ord +--! @brief Index extractor for eql_v3.query_smallint_ord_ope. +--! @param a eql_v3.query_smallint_ord_ope --! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_double_ord) +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_smallint_ord_ope) RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b eql_v3.query_double_ord +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b eql_v3.query_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b eql_v3.query_double_ord) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord. ---! @param a eql_v3.query_double_ord ---! @param b public.eql_v3_double_ord +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. +--! @param a eql_v3.query_smallint_ord_ope +--! @param b public.eql_v3_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord, b public.eql_v3_double_ord) +CREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b eql_v3.query_double_ord +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b eql_v3.query_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b eql_v3.query_double_ord) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord. ---! @param a eql_v3.query_double_ord ---! @param b public.eql_v3_double_ord +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. +--! @param a eql_v3.query_smallint_ord_ope +--! @param b public.eql_v3_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord, b public.eql_v3_double_ord) +CREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b eql_v3.query_double_ord +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b eql_v3.query_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b eql_v3.query_double_ord) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord. ---! @param a eql_v3.query_double_ord ---! @param b public.eql_v3_double_ord +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. +--! @param a eql_v3.query_smallint_ord_ope +--! @param b public.eql_v3_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord, b public.eql_v3_double_ord) +CREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b eql_v3.query_double_ord +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b eql_v3.query_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b eql_v3.query_double_ord) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord. ---! @param a eql_v3.query_double_ord ---! @param b public.eql_v3_double_ord +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. +--! @param a eql_v3.query_smallint_ord_ope +--! @param b public.eql_v3_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord, b public.eql_v3_double_ord) +CREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b eql_v3.query_double_ord +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b eql_v3.query_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b eql_v3.query_double_ord) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord. ---! @param a eql_v3.query_double_ord ---! @param b public.eql_v3_double_ord +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. +--! @param a eql_v3.query_smallint_ord_ope +--! @param b public.eql_v3_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord, b public.eql_v3_double_ord) +CREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b eql_v3.query_double_ord +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b eql_v3.query_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b eql_v3.query_double_ord) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord. ---! @param a eql_v3.query_double_ord ---! @param b public.eql_v3_double_ord +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. +--! @param a eql_v3.query_smallint_ord_ope +--! @param b public.eql_v3_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord, b public.eql_v3_double_ord) +CREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/query_double_ord_ope_functions.sql ---! @brief Functions for eql_v3.query_double_ord_ope. - ---! @brief Index extractor for eql_v3.query_double_ord_ope. ---! @param a eql_v3.query_double_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_double_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.query_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b eql_v3.query_double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_double_ord_ope. ---! @param a eql_v3.query_double_ord_ope ---! @param b public.eql_v3_double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b eql_v3.query_double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_double_ord_ope. ---! @param a eql_v3.query_double_ord_ope ---! @param b public.eql_v3_double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +--! @file encrypted_domain/smallint/query_smallint_ord_ore_functions.sql +--! @brief Functions for eql_v3.query_smallint_ord_ore. ---! @brief Operator wrapper for eql_v3.query_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b eql_v3.query_double_ord_ope +--! @brief Index extractor for eql_v3.query_smallint_ord_ore. +--! @param a eql_v3.query_smallint_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_smallint_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore +--! @param b eql_v3.query_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ope. ---! @param a eql_v3.query_double_ord_ope ---! @param b public.eql_v3_double_ord_ope +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. +--! @param a eql_v3.query_smallint_ord_ore +--! @param b public.eql_v3_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope) +CREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b eql_v3.query_double_ord_ope +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore +--! @param b eql_v3.query_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ope. ---! @param a eql_v3.query_double_ord_ope ---! @param b public.eql_v3_double_ord_ope +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. +--! @param a eql_v3.query_smallint_ord_ore +--! @param b public.eql_v3_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope) +CREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b eql_v3.query_double_ord_ope +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore +--! @param b eql_v3.query_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ope. ---! @param a eql_v3.query_double_ord_ope ---! @param b public.eql_v3_double_ord_ope +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. +--! @param a eql_v3.query_smallint_ord_ore +--! @param b public.eql_v3_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope) +CREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b eql_v3.query_double_ord_ope +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore +--! @param b eql_v3.query_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ope. ---! @param a eql_v3.query_double_ord_ope ---! @param b public.eql_v3_double_ord_ope +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. +--! @param a eql_v3.query_smallint_ord_ore +--! @param b public.eql_v3_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope) +CREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/double/query_double_eq_functions.sql ---! @brief Functions for eql_v3.query_double_eq. - ---! @brief Index extractor for eql_v3.query_double_eq. ---! @param a eql_v3.query_double_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_double_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b eql_v3.query_double_eq +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore +--! @param b eql_v3.query_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b eql_v3.query_double_eq) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_eq. ---! @param a eql_v3.query_double_eq ---! @param b public.eql_v3_double_eq +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. +--! @param a eql_v3.query_smallint_ord_ore +--! @param b public.eql_v3_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_double_eq, b public.eql_v3_double_eq) +CREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b eql_v3.query_double_eq +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore +--! @param b eql_v3.query_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b eql_v3.query_double_eq) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_eq. ---! @param a eql_v3.query_double_eq ---! @param b public.eql_v3_double_eq +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. +--! @param a eql_v3.query_smallint_ord_ore +--! @param b public.eql_v3_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_double_eq, b public.eql_v3_double_eq) +CREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/double_ord_ore_operators.sql ---! @brief Operators for public.eql_v3_double_ord_ore. +--! @file encrypted_domain/smallint/smallint_ord_operators.sql +--! @brief Operators for public.eql_v3_smallint_ord. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/query_smallint_eq_operators.sql +--! @brief Operators for eql_v3.query_smallint_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = eql_v3.query_smallint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = eql_v3.query_smallint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/query_smallint_ord_operators.sql +--! @brief Operators for eql_v3.query_smallint_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_operators.sql +--! @brief Operators for public.eql_v3_smallint. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb +); + CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore + LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore + LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_smallint, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_smallint, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_smallint, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_smallint, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_smallint, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_smallint, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_smallint, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore + LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/double_ord_ope_operators.sql ---! @brief Operators for public.eql_v3_double_ord_ope. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @file encrypted_domain/smallint/query_smallint_ord_ope_operators.sql +--! @brief Operators for eql_v3.query_smallint_ord_ope. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope, + LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope, + LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope, + LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope, + LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope, + LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope, + LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope -); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/double_ord_operators.sql ---! @brief Operators for public.eql_v3_double_ord. +--! @file encrypted_domain/smallint/smallint_eq_operators.sql +--! @brief Operators for public.eql_v3_smallint_eq. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = text + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = text + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = text + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = text + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[] ); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/double/double_functions.sql ---! @brief Functions for public.eql_v3_double. - ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b public.eql_v3_double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b public.eql_v3_double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b public.eql_v3_double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b public.eql_v3_double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/smallint/smallint_ord_ope_aggregates.sql +--! @brief Aggregates for public.eql_v3_smallint_ord_ope. ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +--! @brief State function for min on public.eql_v3_smallint_ord_ope. +--! @param state public.eql_v3_smallint_ord_ope +--! @param value public.eql_v3_smallint_ord_ope +--! @return public.eql_v3_smallint_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord_ope, value public.eql_v3_smallint_ord_ope) +RETURNS public.eql_v3_smallint_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +--! @brief min aggregate for public.eql_v3_smallint_ord_ope. +--! @param input public.eql_v3_smallint_ord_ope +--! @return public.eql_v3_smallint_ord_ope +CREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_smallint_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b public.eql_v3_double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +--! @brief State function for max on public.eql_v3_smallint_ord_ope. +--! @param state public.eql_v3_smallint_ord_ope +--! @param value public.eql_v3_smallint_ord_ope +--! @return public.eql_v3_smallint_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord_ope, value public.eql_v3_smallint_ord_ope) +RETURNS public.eql_v3_smallint_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +--! @brief max aggregate for public.eql_v3_smallint_ord_ope. +--! @param input public.eql_v3_smallint_ord_ope +--! @return public.eql_v3_smallint_ord_ope +CREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_smallint_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/smallint/query_smallint_ord_ore_operators.sql +--! @brief Operators for eql_v3.query_smallint_ord_ore. ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b public.eql_v3_double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b public.eql_v3_double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b public.eql_v3_double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param selector text ---! @return public.eql_v3_double -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double, selector text) -RETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param selector integer ---! @return public.eql_v3_double -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double, selector integer) -RETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param selector public.eql_v3_double ---! @return public.eql_v3_double -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double) -RETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/smallint/smallint_ord_aggregates.sql +--! @brief Aggregates for public.eql_v3_smallint_ord. ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +--! @brief State function for min on public.eql_v3_smallint_ord. +--! @param state public.eql_v3_smallint_ord +--! @param value public.eql_v3_smallint_ord +--! @return public.eql_v3_smallint_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord, value public.eql_v3_smallint_ord) +RETURNS public.eql_v3_smallint_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param selector public.eql_v3_double ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +--! @brief min aggregate for public.eql_v3_smallint_ord. +--! @param input public.eql_v3_smallint_ord +--! @return public.eql_v3_smallint_ord +CREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_smallint_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +--! @brief State function for max on public.eql_v3_smallint_ord. +--! @param state public.eql_v3_smallint_ord +--! @param value public.eql_v3_smallint_ord +--! @return public.eql_v3_smallint_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord, value public.eql_v3_smallint_ord) +RETURNS public.eql_v3_smallint_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +--! @brief max aggregate for public.eql_v3_smallint_ord. +--! @param input public.eql_v3_smallint_ord +--! @return public.eql_v3_smallint_ord +CREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_smallint_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/date/query_date_ord_operators.sql +--! @brief Operators for eql_v3.query_date_ord. ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double, b public.eql_v3_double) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); -- AUTOMATICALLY GENERATED FILE. --! @file encrypted_domain/date/query_date_ord_ore_functions.sql @@ -29855,114 +34003,6 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/query_date_ord_functions.sql ---! @brief Functions for eql_v3.query_date_ord. - ---! @brief Index extractor for eql_v3.query_date_ord. ---! @param a eql_v3.query_date_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_date_ord) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.query_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b eql_v3.query_date_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b eql_v3.query_date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_date_ord. ---! @param a eql_v3.query_date_ord ---! @param b public.eql_v3_date_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord, b public.eql_v3_date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b eql_v3.query_date_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b eql_v3.query_date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_date_ord. ---! @param a eql_v3.query_date_ord ---! @param b public.eql_v3_date_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord, b public.eql_v3_date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b eql_v3.query_date_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b eql_v3.query_date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_date_ord. ---! @param a eql_v3.query_date_ord ---! @param b public.eql_v3_date_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord, b public.eql_v3_date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b eql_v3.query_date_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b eql_v3.query_date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_date_ord. ---! @param a eql_v3.query_date_ord ---! @param b public.eql_v3_date_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord, b public.eql_v3_date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b eql_v3.query_date_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b eql_v3.query_date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_date_ord. ---! @param a eql_v3.query_date_ord ---! @param b public.eql_v3_date_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord, b public.eql_v3_date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b eql_v3.query_date_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b eql_v3.query_date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_date_ord. ---! @param a eql_v3.query_date_ord ---! @param b public.eql_v3_date_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord, b public.eql_v3_date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; --- AUTOMATICALLY GENERATED FILE. - --! @file encrypted_domain/date/query_date_ord_ope_functions.sql --! @brief Functions for eql_v3.query_date_ord_ope. @@ -30071,3706 +34111,2738 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/query_date_eq_functions.sql ---! @brief Functions for eql_v3.query_date_eq. - ---! @brief Index extractor for eql_v3.query_date_eq. ---! @param a eql_v3.query_date_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_date_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.query_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b eql_v3.query_date_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b eql_v3.query_date_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_date_eq. ---! @param a eql_v3.query_date_eq ---! @param b public.eql_v3_date_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_date_eq, b public.eql_v3_date_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b eql_v3.query_date_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b eql_v3.query_date_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_date_eq. ---! @param a eql_v3.query_date_eq ---! @param b public.eql_v3_date_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_date_eq, b public.eql_v3_date_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/date/date_ord_ore_operators.sql ---! @brief Operators for public.eql_v3_date_ord_ore. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/date/date_ord_ope_operators.sql ---! @brief Operators for public.eql_v3_date_ord_ope. +--! @file encrypted_domain/date/date_eq_operators.sql +--! @brief Operators for public.eql_v3_date_eq. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope + LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb + LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope + LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb + LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_date_eq, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer + LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_date_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer + LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_date_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_date_eq, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer + LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope + LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb + LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/date_ord_operators.sql ---! @brief Operators for public.eql_v3_date_ord. +--! @file encrypted_domain/date/date_operators.sql +--! @brief Operators for public.eql_v3_date. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.eql_v3_date, RIGHTARG = jsonb ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.eql_v3_date, RIGHTARG = jsonb ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_date, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_date, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_date, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_date, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord + LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_date, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord + LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_date, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = text + LEFTARG = public.eql_v3_date, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_date, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = text + LEFTARG = public.eql_v3_date, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_date, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = text + LEFTARG = public.eql_v3_date, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_date, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_date, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_date, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_date, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_date, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = text + LEFTARG = public.eql_v3_date, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_date, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_date, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_date, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord + LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_date, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/date_functions.sql ---! @brief Functions for public.eql_v3_date. - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b public.eql_v3_date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b public.eql_v3_date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b public.eql_v3_date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b public.eql_v3_date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b public.eql_v3_date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b public.eql_v3_date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b public.eql_v3_date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b public.eql_v3_date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param selector text ---! @return public.eql_v3_date -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date, selector text) -RETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/date/date_ord_ore_aggregates.sql +--! @brief Aggregates for public.eql_v3_date_ord_ore. ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param selector integer ---! @return public.eql_v3_date -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date, selector integer) -RETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; +--! @brief State function for min on public.eql_v3_date_ord_ore. +--! @param state public.eql_v3_date_ord_ore +--! @param value public.eql_v3_date_ord_ore +--! @return public.eql_v3_date_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord_ore, value public.eql_v3_date_ord_ore) +RETURNS public.eql_v3_date_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param selector public.eql_v3_date ---! @return public.eql_v3_date -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date) -RETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; +--! @brief min aggregate for public.eql_v3_date_ord_ore. +--! @param input public.eql_v3_date_ord_ore +--! @return public.eql_v3_date_ord_ore +CREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_date_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; +--! @brief State function for max on public.eql_v3_date_ord_ore. +--! @param state public.eql_v3_date_ord_ore +--! @param value public.eql_v3_date_ord_ore +--! @return public.eql_v3_date_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord_ore, value public.eql_v3_date_ord_ore) +RETURNS public.eql_v3_date_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; +--! @brief max aggregate for public.eql_v3_date_ord_ore. +--! @param input public.eql_v3_date_ord_ore +--! @return public.eql_v3_date_ord_ore +CREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_date_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param selector public.eql_v3_date ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/date/query_date_eq_functions.sql +--! @brief Functions for eql_v3.query_date_eq. ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; +--! @brief Index extractor for eql_v3.query_date_eq. +--! @param a eql_v3.query_date_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_date_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text[] +--! @brief Operator wrapper for eql_v3.query_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b eql_v3.query_date_eq --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b eql_v3.query_date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text[] +--! @brief Operator wrapper for eql_v3.query_date_eq. +--! @param a eql_v3.query_date_eq +--! @param b public.eql_v3_date_eq --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a eql_v3.query_date_eq, b public.eql_v3_date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonpath +--! @brief Operator wrapper for eql_v3.query_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b eql_v3.query_date_eq --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b eql_v3.query_date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonpath +--! @brief Operator wrapper for eql_v3.query_date_eq. +--! @param a eql_v3.query_date_eq +--! @param b public.eql_v3_date_eq --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a eql_v3.query_date_eq, b public.eql_v3_date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/date/date_ord_ope_aggregates.sql +--! @brief Aggregates for public.eql_v3_date_ord_ope. ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; +--! @brief State function for min on public.eql_v3_date_ord_ope. +--! @param state public.eql_v3_date_ord_ope +--! @param value public.eql_v3_date_ord_ope +--! @return public.eql_v3_date_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord_ope, value public.eql_v3_date_ord_ope) +RETURNS public.eql_v3_date_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date, b public.eql_v3_date) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; +--! @brief min aggregate for public.eql_v3_date_ord_ope. +--! @param input public.eql_v3_date_ord_ope +--! @return public.eql_v3_date_ord_ope +CREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_date_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; +--! @brief State function for max on public.eql_v3_date_ord_ope. +--! @param state public.eql_v3_date_ord_ope +--! @param value public.eql_v3_date_ord_ope +--! @return public.eql_v3_date_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord_ope, value public.eql_v3_date_ord_ope) +RETURNS public.eql_v3_date_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; +--! @brief max aggregate for public.eql_v3_date_ord_ope. +--! @param input public.eql_v3_date_ord_ope +--! @return public.eql_v3_date_ord_ope +CREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_date_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/boolean/boolean_functions.sql ---! @brief Functions for public.eql_v3_boolean. - ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b public.eql_v3_boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/date/query_date_ord_ore_operators.sql +--! @brief Operators for eql_v3.query_date_ord_ore. ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b public.eql_v3_boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b public.eql_v3_boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b public.eql_v3_boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b public.eql_v3_boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/date/date_ord_operators.sql +--! @brief Operators for public.eql_v3_date_ord. ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b public.eql_v3_boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b public.eql_v3_boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b public.eql_v3_boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param selector text ---! @return public.eql_v3_boolean -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_boolean, selector text) -RETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param selector integer ---! @return public.eql_v3_boolean -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_boolean, selector integer) -RETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param selector public.eql_v3_boolean ---! @return public.eql_v3_boolean -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_boolean) -RETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_boolean, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_boolean, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param selector public.eql_v3_boolean ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_boolean) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_boolean, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_boolean, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_boolean, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_boolean, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_boolean, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_boolean, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_boolean, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_boolean, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_boolean, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_boolean, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_boolean, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_boolean, b public.eql_v3_boolean) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_boolean, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_boolean) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer +); ---! @file encrypted_domain/bigint/query_bigint_ord_ore_functions.sql ---! @brief Functions for eql_v3.query_bigint_ord_ore. +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord +); ---! @brief Index extractor for eql_v3.query_bigint_ord_ore. ---! @param a eql_v3.query_bigint_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_bigint_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = text +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b eql_v3.query_bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. ---! @param a eql_v3.query_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b eql_v3.query_bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonpath +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. ---! @param a eql_v3.query_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b eql_v3.query_bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. ---! @param a eql_v3.query_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b eql_v3.query_bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonpath +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. ---! @param a eql_v3.query_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b eql_v3.query_bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. ---! @param a eql_v3.query_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = text +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b eql_v3.query_bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. ---! @param a eql_v3.query_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[] +); ---! @file encrypted_domain/bigint/query_bigint_ord_functions.sql ---! @brief Functions for eql_v3.query_bigint_ord. +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[] +); ---! @brief Index extractor for eql_v3.query_bigint_ord. ---! @param a eql_v3.query_bigint_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_bigint_ord) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b eql_v3.query_bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord. ---! @param a eql_v3.query_bigint_ord ---! @param b public.eql_v3_bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Operator wrapper for eql_v3.query_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b eql_v3.query_bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +--! @file encrypted_domain/date/date_ord_aggregates.sql +--! @brief Aggregates for public.eql_v3_date_ord. ---! @brief Operator wrapper for eql_v3.query_bigint_ord. ---! @param a eql_v3.query_bigint_ord ---! @param b public.eql_v3_bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +--! @brief State function for min on public.eql_v3_date_ord. +--! @param state public.eql_v3_date_ord +--! @param value public.eql_v3_date_ord +--! @return public.eql_v3_date_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord, value public.eql_v3_date_ord) +RETURNS public.eql_v3_date_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b eql_v3.query_bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +--! @brief min aggregate for public.eql_v3_date_ord. +--! @param input public.eql_v3_date_ord +--! @return public.eql_v3_date_ord +CREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_date_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord. ---! @param a eql_v3.query_bigint_ord ---! @param b public.eql_v3_bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +--! @brief State function for max on public.eql_v3_date_ord. +--! @param state public.eql_v3_date_ord +--! @param value public.eql_v3_date_ord +--! @return public.eql_v3_date_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord, value public.eql_v3_date_ord) +RETURNS public.eql_v3_date_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b eql_v3.query_bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +--! @brief max aggregate for public.eql_v3_date_ord. +--! @param input public.eql_v3_date_ord +--! @return public.eql_v3_date_ord +CREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_date_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Operator wrapper for eql_v3.query_bigint_ord. ---! @param a eql_v3.query_bigint_ord ---! @param b public.eql_v3_bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +--! @file encrypted_domain/date/query_date_eq_operators.sql +--! @brief Operators for eql_v3.query_date_eq. ---! @brief Operator wrapper for eql_v3.query_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b eql_v3.query_bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_date_eq, RIGHTARG = eql_v3.query_date_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord. ---! @param a eql_v3.query_bigint_ord ---! @param b public.eql_v3_bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_date_eq, RIGHTARG = public.eql_v3_date_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b eql_v3.query_bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_date_eq, RIGHTARG = eql_v3.query_date_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord. ---! @param a eql_v3.query_bigint_ord ---! @param b public.eql_v3_bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_date_eq, RIGHTARG = public.eql_v3_date_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/bigint/query_bigint_ord_ope_functions.sql ---! @brief Functions for eql_v3.query_bigint_ord_ope. - ---! @brief Index extractor for eql_v3.query_bigint_ord_ope. ---! @param a eql_v3.query_bigint_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_bigint_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +--! @file encrypted_domain/date/query_date_ord_ope_operators.sql +--! @brief Operators for eql_v3.query_date_ord_ope. ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b eql_v3.query_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. ---! @param a eql_v3.query_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b eql_v3.query_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. ---! @param a eql_v3.query_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b eql_v3.query_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. ---! @param a eql_v3.query_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b eql_v3.query_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. ---! @param a eql_v3.query_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b eql_v3.query_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. ---! @param a eql_v3.query_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b eql_v3.query_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. ---! @param a eql_v3.query_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/bigint/query_bigint_eq_functions.sql ---! @brief Functions for eql_v3.query_bigint_eq. +--! @file encrypted_domain/numeric/query_numeric_eq_functions.sql +--! @brief Functions for eql_v3.query_numeric_eq. ---! @brief Index extractor for eql_v3.query_bigint_eq. ---! @param a eql_v3.query_bigint_eq +--! @brief Index extractor for eql_v3.query_numeric_eq. +--! @param a eql_v3.query_numeric_eq --! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_bigint_eq) +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_numeric_eq) RETURNS eql_v3_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b eql_v3.query_bigint_eq +--! @brief Operator wrapper for eql_v3.query_numeric_eq. +--! @param a public.eql_v3_numeric_eq +--! @param b eql_v3.query_numeric_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b eql_v3.query_bigint_eq) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b eql_v3.query_numeric_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_eq. ---! @param a eql_v3.query_bigint_eq ---! @param b public.eql_v3_bigint_eq +--! @brief Operator wrapper for eql_v3.query_numeric_eq. +--! @param a eql_v3.query_numeric_eq +--! @param b public.eql_v3_numeric_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_eq, b public.eql_v3_bigint_eq) +CREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_eq, b public.eql_v3_numeric_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b eql_v3.query_bigint_eq +--! @brief Operator wrapper for eql_v3.query_numeric_eq. +--! @param a public.eql_v3_numeric_eq +--! @param b eql_v3.query_numeric_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b eql_v3.query_bigint_eq) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b eql_v3.query_numeric_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_eq. ---! @param a eql_v3.query_bigint_eq ---! @param b public.eql_v3_bigint_eq +--! @brief Operator wrapper for eql_v3.query_numeric_eq. +--! @param a eql_v3.query_numeric_eq +--! @param b public.eql_v3_numeric_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_eq, b public.eql_v3_bigint_eq) +CREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_eq, b public.eql_v3_numeric_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/bigint/bigint_ord_ore_operators.sql ---! @brief Operators for public.eql_v3_bigint_ord_ore. +--! @file encrypted_domain/numeric/query_numeric_ord_operators.sql +--! @brief Operators for eql_v3.query_numeric_ord. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb, + LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/query_numeric_ord_ore_operators.sql +--! @brief Operators for eql_v3.query_numeric_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore, + LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_functions.sql +--! @brief Functions for public.eql_v3_numeric. + +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b public.eql_v3_numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a jsonb +--! @param b public.eql_v3_numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b public.eql_v3_numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a jsonb +--! @param b public.eql_v3_numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b public.eql_v3_numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a jsonb +--! @param b public.eql_v3_numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b public.eql_v3_numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a jsonb +--! @param b public.eql_v3_numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b public.eql_v3_numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a jsonb +--! @param b public.eql_v3_numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b public.eql_v3_numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a jsonb +--! @param b public.eql_v3_numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b public.eql_v3_numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a jsonb +--! @param b public.eql_v3_numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b public.eql_v3_numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a jsonb +--! @param b public.eql_v3_numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param selector text +--! @return public.eql_v3_numeric +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric, selector text) +RETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param selector integer +--! @return public.eql_v3_numeric +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric, selector integer) +RETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a jsonb +--! @param selector public.eql_v3_numeric +--! @return public.eql_v3_numeric +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric) +RETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a jsonb +--! @param selector public.eql_v3_numeric +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b public.eql_v3_numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a jsonb +--! @param b public.eql_v3_numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b public.eql_v3_numeric +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric, b public.eql_v3_numeric) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a jsonb +--! @param b public.eql_v3_numeric +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/bigint/bigint_ord_ope_operators.sql ---! @brief Operators for public.eql_v3_bigint_ord_ope. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @file encrypted_domain/numeric/query_numeric_ord_ope_operators.sql +--! @brief Operators for eql_v3.query_numeric_ord_ope. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope, + LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope, + LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope, + LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope, + LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope, + LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope -); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/bigint/bigint_ord_operators.sql ---! @brief Operators for public.eql_v3_bigint_ord. +--! @file encrypted_domain/numeric/numeric_eq_operators.sql +--! @brief Operators for public.eql_v3_numeric_eq. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/bigint/bigint_functions.sql ---! @brief Functions for public.eql_v3_bigint. - ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b public.eql_v3_bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b public.eql_v3_bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b public.eql_v3_bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b public.eql_v3_bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/numeric/numeric_ord_ore_aggregates.sql +--! @brief Aggregates for public.eql_v3_numeric_ord_ore. ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +--! @brief State function for min on public.eql_v3_numeric_ord_ore. +--! @param state public.eql_v3_numeric_ord_ore +--! @param value public.eql_v3_numeric_ord_ore +--! @return public.eql_v3_numeric_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord_ore, value public.eql_v3_numeric_ord_ore) +RETURNS public.eql_v3_numeric_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +--! @brief min aggregate for public.eql_v3_numeric_ord_ore. +--! @param input public.eql_v3_numeric_ord_ore +--! @return public.eql_v3_numeric_ord_ore +CREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_numeric_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b public.eql_v3_bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +--! @brief State function for max on public.eql_v3_numeric_ord_ore. +--! @param state public.eql_v3_numeric_ord_ore +--! @param value public.eql_v3_numeric_ord_ore +--! @return public.eql_v3_numeric_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord_ore, value public.eql_v3_numeric_ord_ore) +RETURNS public.eql_v3_numeric_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +--! @brief max aggregate for public.eql_v3_numeric_ord_ore. +--! @param input public.eql_v3_numeric_ord_ore +--! @return public.eql_v3_numeric_ord_ore +CREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_numeric_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/numeric/numeric_operators.sql +--! @brief Operators for public.eql_v3_numeric. ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b public.eql_v3_bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b public.eql_v3_bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b public.eql_v3_bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param selector text ---! @return public.eql_v3_bigint -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint, selector text) -RETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param selector integer ---! @return public.eql_v3_bigint -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint, selector integer) -RETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param selector public.eql_v3_bigint ---! @return public.eql_v3_bigint -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint) -RETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param selector public.eql_v3_bigint ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_numeric, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_numeric, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint, b public.eql_v3_bigint) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_numeric, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_numeric, RIGHTARG = integer +); ---! @file v3/jsonb/functions.sql ---! @brief Extractors, containment engine, and path/array functions for the ---! eql_v3 encrypted-JSONB (SteVec) surface. ---! ---! `selector` parameters here are *encrypted-side* selector hashes — the ---! deterministic hash the crypto layer emits in the `s` field of each sv ---! element. Plaintext JSONPaths are never accepted at runtime. +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric +); ------------------------------------------------------------------------------- --- Envelope helpers (eql_v3 owns these; jsonb-only) ------------------------------------------------------------------------------- +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_numeric, RIGHTARG = text +); ---! @brief Extract metadata (i, v) from a raw jsonb encrypted value. ---! @param val jsonb encrypted EQL payload ---! @return jsonb Metadata object with `i` and `v` fields. -CREATE FUNCTION eql_v3.meta_data(val jsonb) - RETURNS jsonb - IMMUTABLE STRICT PARALLEL SAFE - LANGUAGE SQL -AS $$ - SELECT jsonb_build_object('i', val->'i', 'v', val->'v'); -$$; +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_numeric, RIGHTARG = text[] +); -COMMENT ON FUNCTION eql_v3.meta_data(jsonb) IS - 'eql-inline-critical: raw-jsonb envelope helper used by v3 jsonb wrappers; must stay inlinable (unpinned search_path)'; +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_numeric, RIGHTARG = text[] +); ---! @brief Extract ciphertext (c) from a raw jsonb encrypted value. ---! @param val jsonb encrypted EQL payload ---! @return text Base64-encoded ciphertext. ---! @throws Exception if `c` is absent. -CREATE FUNCTION eql_v3.ciphertext(val jsonb) - RETURNS text - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - BEGIN - IF val ? 'c' THEN - RETURN val->>'c'; - END IF; - RAISE 'Expected a ciphertext (c) value in json: %', val; - END; -$$ LANGUAGE plpgsql; +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonpath +); ------------------------------------------------------------------------------- --- Selector extractors ------------------------------------------------------------------------------- +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric +); ---! @brief Extract selector (s) from a raw jsonb encrypted value. ---! @param val jsonb encrypted EQL payload ---! @return text The selector value. ---! @throws Exception if `s` is absent. -CREATE FUNCTION eql_v3.selector(val jsonb) - RETURNS text - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - BEGIN - IF val ? 's' THEN - RETURN val->>'s'; - END IF; - RAISE 'Expected a selector index (s) value in json: %', val; - END; -$$ LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb +); ---! @brief Extract selector (s) from a ste_vec entry. The DOMAIN CHECK ---! guarantees `s` is present, so this is a simple field access. ---! @param entry public.eql_v3_jsonb_entry ---! @return text The selector value. -CREATE FUNCTION eql_v3.selector(entry public.eql_v3_jsonb_entry) - RETURNS text - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT entry ->> 's' -$$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric +); ------------------------------------------------------------------------------- --- Equality-term extractor (XOR-aware: coalesce(hm, op)) ------------------------------------------------------------------------------- +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonpath +); ---! @brief XOR-aware equality term extractor for public.eql_v3_jsonb_entry. ---! ---! Returns the bytea of whichever deterministic term the sv entry carries — ---! `hm` (HMAC-256) or `op` (CLLW OPE). The two byte distributions are disjoint ---! by construction, so byte equality on the coalesce is unambiguous. Canonical ---! equality extractor used by `=` / `<>` on jsonb_entry. ---! ---! @param entry public.eql_v3_jsonb_entry ---! @return bytea Decoded `hm` or `op` bytes (NULL if entry is NULL). -CREATE FUNCTION eql_v3.eq_term(entry public.eql_v3_jsonb_entry) - RETURNS bytea - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT decode(coalesce(entry ->> 'hm', entry ->> 'op'), 'hex') -$$; +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_numeric, RIGHTARG = text[] +); ------------------------------------------------------------------------------- --- CLLW OPE per-entry overload (converged with the scalar ord_term) ------------------------------------------------------------------------------- +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_numeric, RIGHTARG = text[] +); ---! @brief Extract the CLLW OPE index term from a ste_vec entry. ---! ---! An sv-element `op` term is only ever present on an sv element, never at a ---! root encrypted value, so the typed overload accepts public.eql_v3_jsonb_entry — ---! the jsonb_entry twin of the generated scalar `eql_v3.ord_term` ---! extractors. Returns SQL NULL when `op` is absent (the strict `->>` / ---! `decode` chain propagates it), so btree NULL-filters such rows from range ---! queries. The returned eql_v3_internal.ope_cllw is a bytea domain: it orders ---! under native byte comparison with the DEFAULT btree opclass, so a ---! functional index on `eql_v3.ord_term(col -> 'selector')` engages ---! structurally with no custom operator class (Supabase/managed-Postgres ---! safe). ---! ---! @param entry public.eql_v3_jsonb_entry ---! @return eql_v3_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when ---! `op` is absent. -CREATE FUNCTION eql_v3.ord_term(entry public.eql_v3_jsonb_entry) - RETURNS eql_v3_internal.ope_cllw - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3_internal.ope_cllw(entry::jsonb) -$$; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_numeric, RIGHTARG = text +); ------------------------------------------------------------------------------- --- sv-array helpers ------------------------------------------------------------------------------- +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_numeric, RIGHTARG = integer +); ---! @brief Extract the sv element array as raw jsonb[]. ---! ---! Returns the elements of `sv` (or a single-element array wrapping the value ---! when there is no `sv`). No envelope re-wrapping — raw jsonb elements. ---! ---! @param val jsonb encrypted EQL payload ---! @return jsonb[] Array of sv elements. -CREATE FUNCTION eql_v3.ste_vec(val jsonb) - RETURNS jsonb[] - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - DECLARE - sv jsonb; - ary jsonb[]; - BEGIN - IF val ? 'sv' THEN - sv := val->'sv'; - ELSE - sv := jsonb_build_array(val); - END IF; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_numeric, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_numeric, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric +); - SELECT array_agg(elem) - INTO ary - FROM jsonb_array_elements(sv) AS elem; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb +); - RETURN ary; - END; -$$ LANGUAGE plpgsql; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Check if a jsonb payload is marked as an sv array (`a` flag true). ---! @param val jsonb encrypted EQL payload ---! @return boolean True if `a` is present and true. -CREATE FUNCTION eql_v3_internal.is_ste_vec_array(val jsonb) - RETURNS boolean - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - BEGIN - IF val ? 'a' THEN - RETURN (val->>'a')::boolean; - END IF; - RETURN false; - END; -$$ LANGUAGE plpgsql; +--! @file encrypted_domain/numeric/query_numeric_eq_operators.sql +--! @brief Operators for eql_v3.query_numeric_eq. ------------------------------------------------------------------------------- --- Deterministic-fields array for GIN containment ------------------------------------------------------------------------------- +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = eql_v3.query_numeric_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Extract deterministic search fields (s, hm, op) per sv element. ---! ---! Excludes non-deterministic ciphertext so PostgreSQL's native jsonb `@>` can ---! compare for containment. Use for GIN indexes and containment queries. ---! ---! @param val jsonb encrypted EQL payload ---! @return jsonb[] Array of objects with only deterministic fields. -CREATE FUNCTION eql_v3.jsonb_array(val jsonb) -RETURNS jsonb[] -IMMUTABLE STRICT PARALLEL SAFE -LANGUAGE SQL -AS $$ - SELECT ARRAY( - SELECT jsonb_object_agg(kv.key, kv.value) - FROM jsonb_array_elements( - CASE WHEN val ? 'sv' THEN val->'sv' ELSE jsonb_build_array(val) END - ) AS elem, - LATERAL jsonb_each(elem) AS kv(key, value) - WHERE kv.key IN ('s', 'hm', 'op') - GROUP BY elem - ); -$$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); -COMMENT ON FUNCTION eql_v3.jsonb_array(jsonb) IS - 'eql-inline-critical: raw-jsonb deterministic-field array helper; must stay inlinable (unpinned search_path)'; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = eql_v3.query_numeric_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ------------------------------------------------------------------------------- --- Containment ------------------------------------------------------------------------------- +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief GIN-indexable containment check: does `a` contain all of `b`? ---! @param a jsonb Container payload. ---! @param b jsonb Search payload. ---! @return boolean True if a contains all deterministic elements of b. ---! @note Public raw-`jsonb[]` containment helper over the extracted ---! deterministic fields — the function-form entrypoint for containment on ---! platforms without operator support (Supabase/PostgREST). The typed ---! `public.eql_v3_json` `@>` operator does NOT call this function — it binds to ---! `eql_v3.ste_vec_contains` instead — but both agree on the result (a ---! parity test pins this). Also the documented GIN index expression ---! (`eql_v3.jsonb_array(col)`); see docs/reference/database-indexes.md. -CREATE FUNCTION eql_v3.jsonb_contains(a jsonb, b jsonb) -RETURNS boolean -IMMUTABLE STRICT PARALLEL SAFE -LANGUAGE SQL +--! @file encrypted_domain/numeric/numeric_ord_ope_aggregates.sql +--! @brief Aggregates for public.eql_v3_numeric_ord_ope. + +--! @brief State function for min on public.eql_v3_numeric_ord_ope. +--! @param state public.eql_v3_numeric_ord_ope +--! @param value public.eql_v3_numeric_ord_ope +--! @return public.eql_v3_numeric_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord_ope, value public.eql_v3_numeric_ord_ope) +RETURNS public.eql_v3_numeric_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public AS $$ - SELECT eql_v3.jsonb_array(a) @> eql_v3.jsonb_array(b); +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; $$; -COMMENT ON FUNCTION eql_v3.jsonb_contains(jsonb, jsonb) IS - 'eql-inline-critical: raw-jsonb containment helper; must stay inlinable (unpinned search_path)'; +--! @brief min aggregate for public.eql_v3_numeric_ord_ope. +--! @param input public.eql_v3_numeric_ord_ope +--! @return public.eql_v3_numeric_ord_ope +CREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_numeric_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); ---! @brief GIN-indexable "is contained by" check. ---! @param a jsonb Payload to check. ---! @param b jsonb Container payload. ---! @return boolean True if all elements of a are contained in b. ---! @note Public raw-`jsonb[]` reverse-containment helper — the function-form ---! entrypoint for `<@` on platforms without operator support. The typed ---! `public.eql_v3_json` `<@` operator binds to `eql_v3.ste_vec_contains` instead, ---! but both agree on the result. -CREATE FUNCTION eql_v3.jsonb_contained_by(a jsonb, b jsonb) -RETURNS boolean -IMMUTABLE STRICT PARALLEL SAFE -LANGUAGE SQL +--! @brief State function for max on public.eql_v3_numeric_ord_ope. +--! @param state public.eql_v3_numeric_ord_ope +--! @param value public.eql_v3_numeric_ord_ope +--! @return public.eql_v3_numeric_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord_ope, value public.eql_v3_numeric_ord_ope) +RETURNS public.eql_v3_numeric_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public AS $$ - SELECT eql_v3.jsonb_array(a) <@ eql_v3.jsonb_array(b); +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; $$; -COMMENT ON FUNCTION eql_v3.jsonb_contained_by(jsonb, jsonb) IS - 'eql-inline-critical: raw-jsonb contained-by helper; must stay inlinable (unpinned search_path)'; +--! @brief max aggregate for public.eql_v3_numeric_ord_ope. +--! @param input public.eql_v3_numeric_ord_ope +--! @return public.eql_v3_numeric_ord_ope +CREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_numeric_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Check if an sv array contains a specific sv element. ---! ---! Match = selector equal AND eq_term equal (byte-equality over coalesce(hm, ---! op)). This collapses the v2 hm/oc CASE: under the XOR contract both terms ---! are deterministic and byte-disjoint, so either one is a valid equality ---! discriminator and a single byte comparison is correct. ---! ---! ASSUMPTION (locked by a negative test in v3_jsonb_tests.rs): hm and op byte ---! distributions never collide at a given selector. The crypto layer configures ---! a selector for eq XOR ordered, so both sides of a real comparison carry the ---! same term type — an hm needle never meets an op leaf at the same selector. ---! This collapse would wrongly match an hm needle against an op leaf if their ---! hex bytes were ever identical — which the contract prevents (an hm is a ---! fixed 32-byte HMAC; an op is a CLLW OPE ciphertext whose length is a ---! function of the plaintext bit width, never 32 bytes for the supported ---! domains). The negative-containment test guards against regression. ---! ---! @param a jsonb[] sv array to search within. ---! @param b jsonb sv element to search for. ---! @return boolean True if b is found in any element of a. -CREATE FUNCTION eql_v3.ste_vec_contains(a jsonb[], b jsonb) - RETURNS boolean - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - DECLARE - result boolean; - _a jsonb; - BEGIN - result := false; +--! @file encrypted_domain/numeric/numeric_ord_operators.sql +--! @brief Operators for public.eql_v3_numeric_ord. - FOR idx IN 1..array_length(a, 1) LOOP - _a := a[idx]; - result := result OR ( - eql_v3.selector(_a) = eql_v3.selector(b) - AND eql_v3.eq_term(_a::public.eql_v3_jsonb_entry) = eql_v3.eq_term(b::public.eql_v3_jsonb_entry) - ); - EXIT WHEN result; - END LOOP; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - RETURN result; - END; -$$ LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Does encrypted value `a` contain all sv elements of `b`? ---! ---! Empty b is always contained. Each element of b must match selector + eq_term ---! in some element of a. ---! ---! @param a public.eql_v3_json Container. ---! @param b public.eql_v3_json Elements to find. ---! @return boolean True if all elements of b are contained in a. ---! @see eql_v3.ste_vec_contains(jsonb[], jsonb) -CREATE FUNCTION eql_v3.ste_vec_contains(a public.eql_v3_json, b public.eql_v3_json) - RETURNS boolean - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - DECLARE - result boolean; - sv_a jsonb[]; - sv_b jsonb[]; - _b jsonb; - BEGIN - sv_a := eql_v3.ste_vec(a); - sv_b := eql_v3.ste_vec(b); +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - IF array_length(sv_b, 1) IS NULL THEN - RETURN true; - END IF; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); - IF array_length(sv_a, 1) IS NULL THEN - RETURN false; - END IF; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); - result := true; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); - FOR idx IN 1..array_length(sv_b, 1) LOOP - _b := sv_b[idx]; - result := result AND eql_v3.ste_vec_contains(sv_a, _b); - END LOOP; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); - RETURN result; - END; -$$ LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ------------------------------------------------------------------------------- --- Path queries (text selector only) ------------------------------------------------------------------------------- +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Query encrypted JSONB for sv elements matching `selector`. ---! ---! Returns one jsonb_entry row per matching encrypted element. Returns empty ---! set on no match. It deliberately does not wrap multiple matches as an ---! public.eql_v3_json document, because the root document domain requires an `sv` ---! array and single leaves belong to public.eql_v3_jsonb_entry. ---! ---! @param val jsonb encrypted EQL payload with `sv`. ---! @param selector text Selector hash (`s` value). ---! @return SETOF public.eql_v3_jsonb_entry Matching encrypted entries. ---! @see eql_v3.jsonb_path_query_first -CREATE FUNCTION eql_v3.jsonb_path_query(val jsonb, selector text) - RETURNS SETOF public.eql_v3_jsonb_entry - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_jsonb_entry - FROM jsonb_array_elements(val -> 'sv') elem - WHERE elem ->> 's' = selector -$$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); -COMMENT ON FUNCTION eql_v3.jsonb_path_query(jsonb, text) IS - 'eql-inline-critical: raw-jsonb path query helper; must stay inlinable (unpinned search_path)'; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Check if a selector path exists in encrypted JSONB. ---! @param val jsonb encrypted EQL payload. ---! @param selector text Selector hash to test. ---! @return boolean True if a matching element exists. -CREATE FUNCTION eql_v3.jsonb_path_exists(val jsonb, selector text) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT EXISTS ( - SELECT 1 FROM jsonb_array_elements(val -> 'sv') elem - WHERE elem ->> 's' = selector - ); -$$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); -COMMENT ON FUNCTION eql_v3.jsonb_path_exists(jsonb, text) IS - 'eql-inline-critical: raw-jsonb path exists helper; must stay inlinable (unpinned search_path)'; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Get the first sv element matching `selector`, or NULL. ---! @param val jsonb encrypted EQL payload. ---! @param selector text Selector hash to match. ---! @return public.eql_v3_jsonb_entry First matching element or NULL. -CREATE FUNCTION eql_v3.jsonb_path_query_first(val jsonb, selector text) - RETURNS public.eql_v3_jsonb_entry - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_jsonb_entry - FROM jsonb_array_elements(val -> 'sv') elem - WHERE elem ->> 's' = selector - LIMIT 1 -$$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); -COMMENT ON FUNCTION eql_v3.jsonb_path_query_first(jsonb, text) IS - 'eql-inline-critical: raw-jsonb path first helper; must stay inlinable (unpinned search_path)'; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ------------------------------------------------------------------------------- --- Array functions ------------------------------------------------------------------------------- +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Get the length of an encrypted JSONB array. ---! @param val jsonb encrypted EQL payload (must have `a` flag true). ---! @return integer Number of elements. ---! @throws Exception 'cannot get array length of a non-array' if not an array. -CREATE FUNCTION eql_v3.jsonb_array_length(val jsonb) - RETURNS integer - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - DECLARE - sv jsonb[]; - BEGIN - IF eql_v3_internal.is_ste_vec_array(val) THEN - sv := eql_v3.ste_vec(val); - RETURN array_length(sv, 1); - END IF; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); - RAISE 'cannot get array length of a non-array'; - END; -$$ LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Extract elements of an encrypted JSONB array as rows. ---! @param val jsonb encrypted EQL payload (must have `a` flag true). ---! @return SETOF public.eql_v3_jsonb_entry One row per element (metadata preserved). ---! @throws Exception 'cannot extract elements from non-array' if not an array. -CREATE FUNCTION eql_v3.jsonb_array_elements(val jsonb) - RETURNS SETOF public.eql_v3_jsonb_entry - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - DECLARE - sv jsonb[]; - meta jsonb; - item jsonb; - BEGIN - IF NOT eql_v3_internal.is_ste_vec_array(val) THEN - RAISE 'cannot extract elements from non-array'; - END IF; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord +); - meta := eql_v3.meta_data(val); - sv := eql_v3.ste_vec(val); +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb +); - FOR idx IN 1..array_length(sv, 1) LOOP - item = sv[idx]; - RETURN NEXT (meta || item)::public.eql_v3_jsonb_entry; - END LOOP; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord +); - RETURN; - END; -$$ LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord +); ---! @brief Extract elements of an encrypted JSONB array as ciphertext text. ---! @param val jsonb encrypted EQL payload (must have `a` flag true). ---! @return SETOF text One ciphertext per element. ---! @throws Exception 'cannot extract elements from non-array' if not an array. -CREATE FUNCTION eql_v3.jsonb_array_elements_text(val jsonb) - RETURNS SETOF text - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - DECLARE - sv jsonb[]; - BEGIN - IF NOT eql_v3_internal.is_ste_vec_array(val) THEN - RAISE 'cannot extract elements from non-array'; - END IF; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb +); - sv := eql_v3.ste_vec(val); +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord +); - FOR idx IN 1..array_length(sv, 1) LOOP - RETURN NEXT eql_v3.ciphertext(sv[idx]); - END LOOP; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text +); - RETURN; - END; -$$ LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE --- Source is src/v3/version.template +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[] +); -DROP FUNCTION IF EXISTS eql_v3.version(); +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonpath +); ---! @file v3/version.sql ---! @brief EQL version reporting (self-contained eql_v3 surface) ---! ---! This file is auto-generated from src/v3/version.template during build. ---! The 3.0.0 placeholder is replaced with the actual release ---! version (bare semver, e.g. "3.0.0") supplied via `mise run build --version`, ---! or "DEV" for development builds. +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord +); ---! @brief Get the installed EQL version string ---! ---! Returns the version string for the installed EQL library. This value is ---! baked in at build time from the release tag. ---! ---! @return text Version string (e.g. "3.0.0" or "DEV" for development builds) ---! ---! @note Auto-generated during build from src/v3/version.template ---! ---! Example: `SELECT eql_v3.version()` returns the installed version string, ---! e.g. `'3.0.0'` (or `'DEV'` for development builds). -CREATE FUNCTION eql_v3.version() - RETURNS text - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT '3.0.0'; -$$ LANGUAGE SQL; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb +); ---! @brief Schema-level version marker for obj_description() discoverability ---! ---! Mirrors eql_v3.version() as a comment on the schema so the installed ---! version can also be read via obj_description('eql_v3'::regnamespace). -COMMENT ON SCHEMA eql_v3 IS '3.0.0'; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord +); ---! @file encrypted_domain/timestamp/timestamp_ord_ore_aggregates.sql ---! @brief Aggregates for public.eql_v3_timestamp_ord_ore. +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonpath +); ---! @brief State function for min on public.eql_v3_timestamp_ord_ore. ---! @param state public.eql_v3_timestamp_ord_ore ---! @param value public.eql_v3_timestamp_ord_ore ---! @return public.eql_v3_timestamp_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord_ore, value public.eql_v3_timestamp_ord_ore) -RETURNS public.eql_v3_timestamp_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[] +); ---! @brief min aggregate for public.eql_v3_timestamp_ord_ore. ---! @param input public.eql_v3_timestamp_ord_ore ---! @return public.eql_v3_timestamp_ord_ore -CREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_timestamp_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[] ); ---! @brief State function for max on public.eql_v3_timestamp_ord_ore. ---! @param state public.eql_v3_timestamp_ord_ore ---! @param value public.eql_v3_timestamp_ord_ore ---! @return public.eql_v3_timestamp_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord_ore, value public.eql_v3_timestamp_ord_ore) -RETURNS public.eql_v3_timestamp_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text +); ---! @brief max aggregate for public.eql_v3_timestamp_ord_ore. ---! @param input public.eql_v3_timestamp_ord_ore ---! @return public.eql_v3_timestamp_ord_ore -CREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_timestamp_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer ); --- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/timestamp/timestamp_ord_ope_aggregates.sql ---! @brief Aggregates for public.eql_v3_timestamp_ord_ope. +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[] +); ---! @brief State function for min on public.eql_v3_timestamp_ord_ope. ---! @param state public.eql_v3_timestamp_ord_ope ---! @param value public.eql_v3_timestamp_ord_ope ---! @return public.eql_v3_timestamp_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord_ope, value public.eql_v3_timestamp_ord_ope) -RETURNS public.eql_v3_timestamp_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[] +); ---! @brief min aggregate for public.eql_v3_timestamp_ord_ope. ---! @param input public.eql_v3_timestamp_ord_ope ---! @return public.eql_v3_timestamp_ord_ope -CREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_timestamp_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord ); ---! @brief State function for max on public.eql_v3_timestamp_ord_ope. ---! @param state public.eql_v3_timestamp_ord_ope ---! @param value public.eql_v3_timestamp_ord_ope ---! @return public.eql_v3_timestamp_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord_ope, value public.eql_v3_timestamp_ord_ope) -RETURNS public.eql_v3_timestamp_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb +); ---! @brief max aggregate for public.eql_v3_timestamp_ord_ope. ---! @param input public.eql_v3_timestamp_ord_ope ---! @return public.eql_v3_timestamp_ord_ope -CREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_timestamp_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/timestamp/timestamp_ord_aggregates.sql ---! @brief Aggregates for public.eql_v3_timestamp_ord. +--! @file encrypted_domain/numeric/numeric_ord_aggregates.sql +--! @brief Aggregates for public.eql_v3_numeric_ord. ---! @brief State function for min on public.eql_v3_timestamp_ord. ---! @param state public.eql_v3_timestamp_ord ---! @param value public.eql_v3_timestamp_ord ---! @return public.eql_v3_timestamp_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord, value public.eql_v3_timestamp_ord) -RETURNS public.eql_v3_timestamp_ord +--! @brief State function for min on public.eql_v3_numeric_ord. +--! @param state public.eql_v3_numeric_ord +--! @param value public.eql_v3_numeric_ord +--! @return public.eql_v3_numeric_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord, value public.eql_v3_numeric_ord) +RETURNS public.eql_v3_numeric_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -33782,22 +36854,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_timestamp_ord. ---! @param input public.eql_v3_timestamp_ord ---! @return public.eql_v3_timestamp_ord -CREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord) ( +--! @brief min aggregate for public.eql_v3_numeric_ord. +--! @param input public.eql_v3_numeric_ord +--! @return public.eql_v3_numeric_ord +CREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord) ( sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_timestamp_ord, + stype = public.eql_v3_numeric_ord, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_timestamp_ord. ---! @param state public.eql_v3_timestamp_ord ---! @param value public.eql_v3_timestamp_ord ---! @return public.eql_v3_timestamp_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord, value public.eql_v3_timestamp_ord) -RETURNS public.eql_v3_timestamp_ord +--! @brief State function for max on public.eql_v3_numeric_ord. +--! @param state public.eql_v3_numeric_ord +--! @param value public.eql_v3_numeric_ord +--! @return public.eql_v3_numeric_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord, value public.eql_v3_numeric_ord) +RETURNS public.eql_v3_numeric_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -33809,910 +36881,1172 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_timestamp_ord. ---! @param input public.eql_v3_timestamp_ord ---! @return public.eql_v3_timestamp_ord -CREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord) ( +--! @brief max aggregate for public.eql_v3_numeric_ord. +--! @param input public.eql_v3_numeric_ord +--! @return public.eql_v3_numeric_ord +CREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord) ( sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_timestamp_ord, + stype = public.eql_v3_numeric_ord, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/timestamp/timestamp_operators.sql ---! @brief Operators for public.eql_v3_timestamp. +--! @file encrypted_domain/json/json_operators.sql +--! @brief Operators for public.eql_v3_json. CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp + LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp + LEFTARG = jsonb, RIGHTARG = public.eql_v3_json ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp + LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp + LEFTARG = jsonb, RIGHTARG = public.eql_v3_json ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp + LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_json, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_json, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_json, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_json, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_json, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_json, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_json, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_json, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_json, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_json, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_json, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_json, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_json, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_json ); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/boolean/boolean_types.sql +--! @brief Encrypted-domain types for boolean. + +DO $$ +BEGIN + --! @brief Encrypted domain public.eql_v3_boolean. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'eql_v3_boolean' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.eql_v3_boolean AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.eql_v3_boolean IS 'EQL encrypted boolean (storage only)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/boolean/boolean_functions.sql +--! @brief Functions for public.eql_v3_boolean. + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a jsonb +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a jsonb +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a jsonb +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a jsonb +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a jsonb +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a jsonb +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a jsonb +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a jsonb +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param selector text +--! @return public.eql_v3_boolean +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_boolean, selector text) +RETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param selector integer +--! @return public.eql_v3_boolean +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_boolean, selector integer) +RETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a jsonb +--! @param selector public.eql_v3_boolean +--! @return public.eql_v3_boolean +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_boolean) +RETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_boolean, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_boolean, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a jsonb +--! @param selector public.eql_v3_boolean +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_boolean) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_boolean, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_boolean, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_boolean, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_boolean, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_boolean, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a jsonb +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_boolean, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_boolean, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_boolean, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_boolean, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_boolean, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_boolean, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_boolean, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b public.eql_v3_boolean +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_boolean, b public.eql_v3_boolean) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_boolean, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a jsonb +--! @param b public.eql_v3_boolean +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_boolean) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/timestamp/timestamp_eq_operators.sql ---! @brief Operators for public.eql_v3_timestamp_eq. +--! @file encrypted_domain/boolean/boolean_operators.sql +--! @brief Operators for public.eql_v3_boolean. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq + LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq + LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq + LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq + LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq + LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq + LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text + LEFTARG = public.eql_v3_boolean, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_boolean, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text + LEFTARG = public.eql_v3_boolean, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_boolean, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text + LEFTARG = public.eql_v3_boolean, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_boolean, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_boolean, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_boolean, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_boolean, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text + LEFTARG = public.eql_v3_boolean, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_boolean, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_boolean, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_boolean, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq + LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/query_timestamp_ord_ore_operators.sql ---! @brief Operators for eql_v3.query_timestamp_ord_ore. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/query_timestamp_ord_operators.sql ---! @brief Operators for eql_v3.query_timestamp_ord. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/timestamp/query_timestamp_ord_ope_operators.sql ---! @brief Operators for eql_v3.query_timestamp_ord_ope. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @file encrypted_domain/double/query_double_ord_functions.sql +--! @brief Functions for eql_v3.query_double_ord. -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Index extractor for eql_v3.query_double_ord. +--! @param a eql_v3.query_double_ord +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_double_ord) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for eql_v3.query_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b eql_v3.query_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b eql_v3.query_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for eql_v3.query_double_ord. +--! @param a eql_v3.query_double_ord +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord, b public.eql_v3_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for eql_v3.query_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b eql_v3.query_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b eql_v3.query_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for eql_v3.query_double_ord. +--! @param a eql_v3.query_double_ord +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord, b public.eql_v3_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for eql_v3.query_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b eql_v3.query_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b eql_v3.query_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Operator wrapper for eql_v3.query_double_ord. +--! @param a eql_v3.query_double_ord +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord, b public.eql_v3_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Operator wrapper for eql_v3.query_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b eql_v3.query_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b eql_v3.query_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @file encrypted_domain/timestamp/query_timestamp_eq_operators.sql ---! @brief Operators for eql_v3.query_timestamp_eq. +--! @brief Operator wrapper for eql_v3.query_double_ord. +--! @param a eql_v3.query_double_ord +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord, b public.eql_v3_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = eql_v3.query_timestamp_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b eql_v3.query_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b eql_v3.query_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_double_ord. +--! @param a eql_v3.query_double_ord +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord, b public.eql_v3_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = eql_v3.query_timestamp_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b eql_v3.query_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b eql_v3.query_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_double_ord. +--! @param a eql_v3.query_double_ord +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord, b public.eql_v3_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_search_ore_aggregates.sql ---! @brief Aggregates for public.eql_v3_text_search_ore. - ---! @brief State function for min on public.eql_v3_text_search_ore. ---! @param state public.eql_v3_text_search_ore ---! @param value public.eql_v3_text_search_ore ---! @return public.eql_v3_text_search_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_search_ore, value public.eql_v3_text_search_ore) -RETURNS public.eql_v3_text_search_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for public.eql_v3_text_search_ore. ---! @param input public.eql_v3_text_search_ore ---! @return public.eql_v3_text_search_ore -CREATE AGGREGATE eql_v3.min(public.eql_v3_text_search_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_text_search_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); +--! @file encrypted_domain/double/query_double_ord_ore_functions.sql +--! @brief Functions for eql_v3.query_double_ord_ore. ---! @brief State function for max on public.eql_v3_text_search_ore. ---! @param state public.eql_v3_text_search_ore ---! @param value public.eql_v3_text_search_ore ---! @return public.eql_v3_text_search_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_search_ore, value public.eql_v3_text_search_ore) -RETURNS public.eql_v3_text_search_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Index extractor for eql_v3.query_double_ord_ore. +--! @param a eql_v3.query_double_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_double_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; ---! @brief max aggregate for public.eql_v3_text_search_ore. ---! @param input public.eql_v3_text_search_ore ---! @return public.eql_v3_text_search_ore -CREATE AGGREGATE eql_v3.max(public.eql_v3_text_search_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_text_search_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Operator wrapper for eql_v3.query_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b eql_v3.query_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; ---! @file encrypted_domain/text/text_search_aggregates.sql ---! @brief Aggregates for public.eql_v3_text_search. +--! @brief Operator wrapper for eql_v3.query_double_ord_ore. +--! @param a eql_v3.query_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; ---! @brief State function for min on public.eql_v3_text_search. ---! @param state public.eql_v3_text_search ---! @param value public.eql_v3_text_search ---! @return public.eql_v3_text_search -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_search, value public.eql_v3_text_search) -RETURNS public.eql_v3_text_search -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Operator wrapper for eql_v3.query_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b eql_v3.query_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; ---! @brief min aggregate for public.eql_v3_text_search. ---! @param input public.eql_v3_text_search ---! @return public.eql_v3_text_search -CREATE AGGREGATE eql_v3.min(public.eql_v3_text_search) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_text_search, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); +--! @brief Operator wrapper for eql_v3.query_double_ord_ore. +--! @param a eql_v3.query_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; ---! @brief State function for max on public.eql_v3_text_search. ---! @param state public.eql_v3_text_search ---! @param value public.eql_v3_text_search ---! @return public.eql_v3_text_search -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_search, value public.eql_v3_text_search) -RETURNS public.eql_v3_text_search -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Operator wrapper for eql_v3.query_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b eql_v3.query_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief max aggregate for public.eql_v3_text_search. ---! @param input public.eql_v3_text_search ---! @return public.eql_v3_text_search -CREATE AGGREGATE eql_v3.max(public.eql_v3_text_search) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_text_search, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Operator wrapper for eql_v3.query_double_ord_ore. +--! @param a eql_v3.query_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @file encrypted_domain/text/text_ord_ore_aggregates.sql ---! @brief Aggregates for public.eql_v3_text_ord_ore. +--! @brief Operator wrapper for eql_v3.query_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b eql_v3.query_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief State function for min on public.eql_v3_text_ord_ore. ---! @param state public.eql_v3_text_ord_ore ---! @param value public.eql_v3_text_ord_ore ---! @return public.eql_v3_text_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord_ore, value public.eql_v3_text_ord_ore) -RETURNS public.eql_v3_text_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Operator wrapper for eql_v3.query_double_ord_ore. +--! @param a eql_v3.query_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief min aggregate for public.eql_v3_text_ord_ore. ---! @param input public.eql_v3_text_ord_ore ---! @return public.eql_v3_text_ord_ore -CREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_text_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); +--! @brief Operator wrapper for eql_v3.query_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b eql_v3.query_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief State function for max on public.eql_v3_text_ord_ore. ---! @param state public.eql_v3_text_ord_ore ---! @param value public.eql_v3_text_ord_ore ---! @return public.eql_v3_text_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord_ore, value public.eql_v3_text_ord_ore) -RETURNS public.eql_v3_text_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Operator wrapper for eql_v3.query_double_ord_ore. +--! @param a eql_v3.query_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief max aggregate for public.eql_v3_text_ord_ore. ---! @param input public.eql_v3_text_ord_ore ---! @return public.eql_v3_text_ord_ore -CREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_text_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); +--! @brief Operator wrapper for eql_v3.query_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b eql_v3.query_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord_ore. +--! @param a eql_v3.query_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_ord_ope_aggregates.sql ---! @brief Aggregates for public.eql_v3_text_ord_ope. +--! @file encrypted_domain/double/double_ord_aggregates.sql +--! @brief Aggregates for public.eql_v3_double_ord. ---! @brief State function for min on public.eql_v3_text_ord_ope. ---! @param state public.eql_v3_text_ord_ope ---! @param value public.eql_v3_text_ord_ope ---! @return public.eql_v3_text_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord_ope, value public.eql_v3_text_ord_ope) -RETURNS public.eql_v3_text_ord_ope +--! @brief State function for min on public.eql_v3_double_ord. +--! @param state public.eql_v3_double_ord +--! @param value public.eql_v3_double_ord +--! @return public.eql_v3_double_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord, value public.eql_v3_double_ord) +RETURNS public.eql_v3_double_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -34724,22 +38058,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_text_ord_ope. ---! @param input public.eql_v3_text_ord_ope ---! @return public.eql_v3_text_ord_ope -CREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord_ope) ( +--! @brief min aggregate for public.eql_v3_double_ord. +--! @param input public.eql_v3_double_ord +--! @return public.eql_v3_double_ord +CREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord) ( sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_text_ord_ope, + stype = public.eql_v3_double_ord, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_text_ord_ope. ---! @param state public.eql_v3_text_ord_ope ---! @param value public.eql_v3_text_ord_ope ---! @return public.eql_v3_text_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord_ope, value public.eql_v3_text_ord_ope) -RETURNS public.eql_v3_text_ord_ope +--! @brief State function for max on public.eql_v3_double_ord. +--! @param state public.eql_v3_double_ord +--! @param value public.eql_v3_double_ord +--! @return public.eql_v3_double_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord, value public.eql_v3_double_ord) +RETURNS public.eql_v3_double_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -34751,26 +38085,26 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_text_ord_ope. ---! @param input public.eql_v3_text_ord_ope ---! @return public.eql_v3_text_ord_ope -CREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord_ope) ( +--! @brief max aggregate for public.eql_v3_double_ord. +--! @param input public.eql_v3_double_ord +--! @return public.eql_v3_double_ord +CREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord) ( sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_text_ord_ope, + stype = public.eql_v3_double_ord, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_ord_aggregates.sql ---! @brief Aggregates for public.eql_v3_text_ord. +--! @file encrypted_domain/double/double_ord_ope_aggregates.sql +--! @brief Aggregates for public.eql_v3_double_ord_ope. ---! @brief State function for min on public.eql_v3_text_ord. ---! @param state public.eql_v3_text_ord ---! @param value public.eql_v3_text_ord ---! @return public.eql_v3_text_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord, value public.eql_v3_text_ord) -RETURNS public.eql_v3_text_ord +--! @brief State function for min on public.eql_v3_double_ord_ope. +--! @param state public.eql_v3_double_ord_ope +--! @param value public.eql_v3_double_ord_ope +--! @return public.eql_v3_double_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord_ope, value public.eql_v3_double_ord_ope) +RETURNS public.eql_v3_double_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -34782,22 +38116,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_text_ord. ---! @param input public.eql_v3_text_ord ---! @return public.eql_v3_text_ord -CREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord) ( +--! @brief min aggregate for public.eql_v3_double_ord_ope. +--! @param input public.eql_v3_double_ord_ope +--! @return public.eql_v3_double_ord_ope +CREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord_ope) ( sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_text_ord, + stype = public.eql_v3_double_ord_ope, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_text_ord. ---! @param state public.eql_v3_text_ord ---! @param value public.eql_v3_text_ord ---! @return public.eql_v3_text_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord, value public.eql_v3_text_ord) -RETURNS public.eql_v3_text_ord +--! @brief State function for max on public.eql_v3_double_ord_ope. +--! @param state public.eql_v3_double_ord_ope +--! @param value public.eql_v3_double_ord_ope +--! @return public.eql_v3_double_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord_ope, value public.eql_v3_double_ord_ope) +RETURNS public.eql_v3_double_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -34809,1252 +38143,932 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_text_ord. ---! @param input public.eql_v3_text_ord ---! @return public.eql_v3_text_ord -CREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord) ( +--! @brief max aggregate for public.eql_v3_double_ord_ope. +--! @param input public.eql_v3_double_ord_ope +--! @return public.eql_v3_double_ord_ope +CREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord_ope) ( sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_text_ord, + stype = public.eql_v3_double_ord_ope, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_operators.sql ---! @brief Operators for public.eql_v3_text. +--! @file encrypted_domain/double/double_operators.sql +--! @brief Operators for public.eql_v3_double. CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text + LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_text, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double, RIGHTARG = jsonb ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text + LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_text, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double, RIGHTARG = jsonb ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text + LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_text, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text + LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_text, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text + LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_text, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text + LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_text, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text + LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_text, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text + LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_text, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text, RIGHTARG = text + LEFTARG = public.eql_v3_double, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text, RIGHTARG = integer + LEFTARG = public.eql_v3_double, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text, RIGHTARG = text + LEFTARG = public.eql_v3_double, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text, RIGHTARG = integer + LEFTARG = public.eql_v3_double, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_text, RIGHTARG = text + LEFTARG = public.eql_v3_double, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_text, RIGHTARG = text[] + LEFTARG = public.eql_v3_double, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_text, RIGHTARG = text[] + LEFTARG = public.eql_v3_double, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_text, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_double, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_text, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_text, RIGHTARG = text[] + LEFTARG = public.eql_v3_double, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_text, RIGHTARG = text[] + LEFTARG = public.eql_v3_double, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text, RIGHTARG = text + LEFTARG = public.eql_v3_double, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text, RIGHTARG = integer + LEFTARG = public.eql_v3_double, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text, RIGHTARG = text[] + LEFTARG = public.eql_v3_double, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_text, RIGHTARG = text[] + LEFTARG = public.eql_v3_double, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text + LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_match_operators.sql ---! @brief Operators for public.eql_v3_text_match. - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match -); +--! @file encrypted_domain/double/query_double_eq_operators.sql +--! @brief Operators for eql_v3.query_double_eq. CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_double_eq, RIGHTARG = eql_v3.query_double_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_double_eq, RIGHTARG = public.eql_v3_double_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_double_eq, RIGHTARG = eql_v3.query_double_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_match, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_match, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_match, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_match, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_text_match, RIGHTARG = text + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_double_eq, RIGHTARG = public.eql_v3_double_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_text_match, RIGHTARG = text[] -); +--! @file encrypted_domain/double/query_double_ord_ope_functions.sql +--! @brief Functions for eql_v3.query_double_ord_ope. -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_text_match, RIGHTARG = text[] -); +--! @brief Index extractor for eql_v3.query_double_ord_ope. +--! @param a eql_v3.query_double_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_double_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonpath -); +--! @brief Operator wrapper for eql_v3.query_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b eql_v3.query_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonpath -); +--! @brief Operator wrapper for eql_v3.query_double_ord_ope. +--! @param a eql_v3.query_double_ord_ope +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_text_match, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b eql_v3.query_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_text_match, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_double_ord_ope. +--! @param a eql_v3.query_double_ord_ope +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_match, RIGHTARG = text -); +--! @brief Operator wrapper for eql_v3.query_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b eql_v3.query_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_match, RIGHTARG = integer -); +--! @brief Operator wrapper for eql_v3.query_double_ord_ope. +--! @param a eql_v3.query_double_ord_ope +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_match, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b eql_v3.query_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_text_match, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_double_ord_ope. +--! @param a eql_v3.query_double_ord_ope +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match -); +--! @brief Operator wrapper for eql_v3.query_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b eql_v3.query_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb -); +--! @brief Operator wrapper for eql_v3.query_double_ord_ope. +--! @param a eql_v3.query_double_ord_ope +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match -); +--! @brief Operator wrapper for eql_v3.query_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b eql_v3.query_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord_ope. +--! @param a eql_v3.query_double_ord_ope +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_eq_operators.sql ---! @brief Operators for public.eql_v3_text_eq. +--! @file encrypted_domain/double/double_eq_operators.sql +--! @brief Operators for public.eql_v3_double_eq. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq, + LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq, + LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq + LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq + LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq + LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq + LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq + LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq + LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = text + LEFTARG = public.eql_v3_double_eq, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = text + LEFTARG = public.eql_v3_double_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = text + LEFTARG = public.eql_v3_double_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = text + LEFTARG = public.eql_v3_double_eq, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq + LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/query_text_search_ore_operators.sql ---! @brief Operators for eql_v3.query_text_search_ore. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/query_text_search_operators.sql ---! @brief Operators for eql_v3.query_text_search. +--! @file encrypted_domain/double/query_double_ord_ore_operators.sql +--! @brief Operators for eql_v3.query_double_ord_ore. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/query_text_ord_ore_operators.sql ---! @brief Operators for eql_v3.query_text_ord_ore. +--! @file encrypted_domain/double/query_double_ord_operators.sql +--! @brief Operators for eql_v3.query_double_ord. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/query_text_ord_operators.sql ---! @brief Operators for eql_v3.query_text_ord. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @file encrypted_domain/double/double_ord_ore_aggregates.sql +--! @brief Aggregates for public.eql_v3_double_ord_ore. -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief State function for min on public.eql_v3_double_ord_ore. +--! @param state public.eql_v3_double_ord_ore +--! @param value public.eql_v3_double_ord_ore +--! @return public.eql_v3_double_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord_ore, value public.eql_v3_double_ord_ore) +RETURNS public.eql_v3_double_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +--! @brief min aggregate for public.eql_v3_double_ord_ore. +--! @param input public.eql_v3_double_ord_ore +--! @return public.eql_v3_double_ord_ore +CREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_double_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe ); -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief State function for max on public.eql_v3_double_ord_ore. +--! @param state public.eql_v3_double_ord_ore +--! @param value public.eql_v3_double_ord_ore +--! @return public.eql_v3_double_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord_ore, value public.eql_v3_double_ord_ore) +RETURNS public.eql_v3_double_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +--! @brief max aggregate for public.eql_v3_double_ord_ore. +--! @param input public.eql_v3_double_ord_ore +--! @return public.eql_v3_double_ord_ore +CREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_double_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/query_text_ord_ope_operators.sql ---! @brief Operators for eql_v3.query_text_ord_ope. +--! @file encrypted_domain/double/query_double_ord_ope_operators.sql +--! @brief Operators for eql_v3.query_double_ord_ope. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, + LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, + LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, + LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, + LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, + LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, + LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/query_text_match_operators.sql ---! @brief Operators for eql_v3.query_text_match. - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = public.eql_v3_text_match, RIGHTARG = eql_v3.query_text_match, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.query_text_match, RIGHTARG = public.eql_v3_text_match, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = public.eql_v3_text_match, RIGHTARG = eql_v3.query_text_match, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.query_text_match, RIGHTARG = public.eql_v3_text_match, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/query_text_eq_operators.sql ---! @brief Operators for eql_v3.query_text_eq. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = eql_v3.query_text_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_text_eq, RIGHTARG = public.eql_v3_text_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = eql_v3.query_text_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_text_eq, RIGHTARG = public.eql_v3_text_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/smallint_ord_ore_aggregates.sql ---! @brief Aggregates for public.eql_v3_smallint_ord_ore. - ---! @brief State function for min on public.eql_v3_smallint_ord_ore. ---! @param state public.eql_v3_smallint_ord_ore ---! @param value public.eql_v3_smallint_ord_ore ---! @return public.eql_v3_smallint_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord_ore, value public.eql_v3_smallint_ord_ore) -RETURNS public.eql_v3_smallint_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for public.eql_v3_smallint_ord_ore. ---! @param input public.eql_v3_smallint_ord_ore ---! @return public.eql_v3_smallint_ord_ore -CREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_smallint_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on public.eql_v3_smallint_ord_ore. ---! @param state public.eql_v3_smallint_ord_ore ---! @param value public.eql_v3_smallint_ord_ore ---! @return public.eql_v3_smallint_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord_ore, value public.eql_v3_smallint_ord_ore) -RETURNS public.eql_v3_smallint_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for public.eql_v3_smallint_ord_ore. ---! @param input public.eql_v3_smallint_ord_ore ---! @return public.eql_v3_smallint_ord_ore -CREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_smallint_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/smallint_ord_ope_aggregates.sql ---! @brief Aggregates for public.eql_v3_smallint_ord_ope. +--! @file encrypted_domain/integer/integer_ord_aggregates.sql +--! @brief Aggregates for public.eql_v3_integer_ord. ---! @brief State function for min on public.eql_v3_smallint_ord_ope. ---! @param state public.eql_v3_smallint_ord_ope ---! @param value public.eql_v3_smallint_ord_ope ---! @return public.eql_v3_smallint_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord_ope, value public.eql_v3_smallint_ord_ope) -RETURNS public.eql_v3_smallint_ord_ope +--! @brief State function for min on public.eql_v3_integer_ord. +--! @param state public.eql_v3_integer_ord +--! @param value public.eql_v3_integer_ord +--! @return public.eql_v3_integer_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord, value public.eql_v3_integer_ord) +RETURNS public.eql_v3_integer_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -36066,22 +39080,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_smallint_ord_ope. ---! @param input public.eql_v3_smallint_ord_ope ---! @return public.eql_v3_smallint_ord_ope -CREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord_ope) ( +--! @brief min aggregate for public.eql_v3_integer_ord. +--! @param input public.eql_v3_integer_ord +--! @return public.eql_v3_integer_ord +CREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord) ( sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_smallint_ord_ope, + stype = public.eql_v3_integer_ord, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_smallint_ord_ope. ---! @param state public.eql_v3_smallint_ord_ope ---! @param value public.eql_v3_smallint_ord_ope ---! @return public.eql_v3_smallint_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord_ope, value public.eql_v3_smallint_ord_ope) -RETURNS public.eql_v3_smallint_ord_ope +--! @brief State function for max on public.eql_v3_integer_ord. +--! @param state public.eql_v3_integer_ord +--! @param value public.eql_v3_integer_ord +--! @return public.eql_v3_integer_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord, value public.eql_v3_integer_ord) +RETURNS public.eql_v3_integer_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -36093,26 +39107,26 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_smallint_ord_ope. ---! @param input public.eql_v3_smallint_ord_ope ---! @return public.eql_v3_smallint_ord_ope -CREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord_ope) ( +--! @brief max aggregate for public.eql_v3_integer_ord. +--! @param input public.eql_v3_integer_ord +--! @return public.eql_v3_integer_ord +CREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord) ( sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_smallint_ord_ope, + stype = public.eql_v3_integer_ord, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/smallint/smallint_ord_aggregates.sql ---! @brief Aggregates for public.eql_v3_smallint_ord. +--! @file encrypted_domain/integer/integer_ord_ore_aggregates.sql +--! @brief Aggregates for public.eql_v3_integer_ord_ore. ---! @brief State function for min on public.eql_v3_smallint_ord. ---! @param state public.eql_v3_smallint_ord ---! @param value public.eql_v3_smallint_ord ---! @return public.eql_v3_smallint_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord, value public.eql_v3_smallint_ord) -RETURNS public.eql_v3_smallint_ord +--! @brief State function for min on public.eql_v3_integer_ord_ore. +--! @param state public.eql_v3_integer_ord_ore +--! @param value public.eql_v3_integer_ord_ore +--! @return public.eql_v3_integer_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord_ore, value public.eql_v3_integer_ord_ore) +RETURNS public.eql_v3_integer_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -36124,22 +39138,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_smallint_ord. ---! @param input public.eql_v3_smallint_ord ---! @return public.eql_v3_smallint_ord -CREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord) ( +--! @brief min aggregate for public.eql_v3_integer_ord_ore. +--! @param input public.eql_v3_integer_ord_ore +--! @return public.eql_v3_integer_ord_ore +CREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord_ore) ( sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_smallint_ord, + stype = public.eql_v3_integer_ord_ore, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_smallint_ord. ---! @param state public.eql_v3_smallint_ord ---! @param value public.eql_v3_smallint_ord ---! @return public.eql_v3_smallint_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord, value public.eql_v3_smallint_ord) -RETURNS public.eql_v3_smallint_ord +--! @brief State function for max on public.eql_v3_integer_ord_ore. +--! @param state public.eql_v3_integer_ord_ore +--! @param value public.eql_v3_integer_ord_ore +--! @return public.eql_v3_integer_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord_ore, value public.eql_v3_integer_ord_ore) +RETURNS public.eql_v3_integer_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -36151,1611 +39165,1396 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_smallint_ord. ---! @param input public.eql_v3_smallint_ord ---! @return public.eql_v3_smallint_ord -CREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord) ( +--! @brief max aggregate for public.eql_v3_integer_ord_ore. +--! @param input public.eql_v3_integer_ord_ore +--! @return public.eql_v3_integer_ord_ore +CREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord_ore) ( sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_smallint_ord, + stype = public.eql_v3_integer_ord_ore, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/smallint/smallint_operators.sql ---! @brief Operators for public.eql_v3_smallint. - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_smallint, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_smallint, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_smallint, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_smallint, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_smallint, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_smallint, RIGHTARG = text[] -); +--! @file encrypted_domain/integer/query_integer_ord_ore_functions.sql +--! @brief Functions for eql_v3.query_integer_ord_ore. -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_smallint, RIGHTARG = text[] -); +--! @brief Index extractor for eql_v3.query_integer_ord_ore. +--! @param a eql_v3.query_integer_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_integer_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonpath -); +--! @brief Operator wrapper for eql_v3.query_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b eql_v3.query_integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonpath -); +--! @brief Operator wrapper for eql_v3.query_integer_ord_ore. +--! @param a eql_v3.query_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_smallint, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b eql_v3.query_integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_smallint, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_integer_ord_ore. +--! @param a eql_v3.query_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint, RIGHTARG = text -); +--! @brief Operator wrapper for eql_v3.query_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b eql_v3.query_integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint, RIGHTARG = integer -); +--! @brief Operator wrapper for eql_v3.query_integer_ord_ore. +--! @param a eql_v3.query_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b eql_v3.query_integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_smallint, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_integer_ord_ore. +--! @param a eql_v3.query_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint -); +--! @brief Operator wrapper for eql_v3.query_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b eql_v3.query_integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb -); +--! @brief Operator wrapper for eql_v3.query_integer_ord_ore. +--! @param a eql_v3.query_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint -); +--! @brief Operator wrapper for eql_v3.query_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b eql_v3.query_integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_integer_ord_ore. +--! @param a eql_v3.query_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/smallint/smallint_eq_operators.sql ---! @brief Operators for public.eql_v3_smallint_eq. +--! @file encrypted_domain/integer/integer_ord_ope_operators.sql +--! @brief Operators for public.eql_v3_integer_ord_ope. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/query_smallint_ord_ore_operators.sql ---! @brief Operators for eql_v3.query_smallint_ord_ore. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/query_smallint_ord_operators.sql ---! @brief Operators for eql_v3.query_smallint_ord. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/query_smallint_ord_ope_operators.sql ---! @brief Operators for eql_v3.query_smallint_ord_ope. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/query_smallint_eq_operators.sql ---! @brief Operators for eql_v3.query_smallint_eq. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = eql_v3.query_smallint_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = eql_v3.query_smallint_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/real_ord_ore_aggregates.sql ---! @brief Aggregates for public.eql_v3_real_ord_ore. - ---! @brief State function for min on public.eql_v3_real_ord_ore. ---! @param state public.eql_v3_real_ord_ore ---! @param value public.eql_v3_real_ord_ore ---! @return public.eql_v3_real_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord_ore, value public.eql_v3_real_ord_ore) -RETURNS public.eql_v3_real_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @file encrypted_domain/integer/query_integer_ord_ope_functions.sql +--! @brief Functions for eql_v3.query_integer_ord_ope. ---! @brief min aggregate for public.eql_v3_real_ord_ore. ---! @param input public.eql_v3_real_ord_ore ---! @return public.eql_v3_real_ord_ore -CREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_real_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); +--! @brief Index extractor for eql_v3.query_integer_ord_ope. +--! @param a eql_v3.query_integer_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_integer_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief State function for max on public.eql_v3_real_ord_ore. ---! @param state public.eql_v3_real_ord_ore ---! @param value public.eql_v3_real_ord_ore ---! @return public.eql_v3_real_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord_ore, value public.eql_v3_real_ord_ore) -RETURNS public.eql_v3_real_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Operator wrapper for eql_v3.query_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b eql_v3.query_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief max aggregate for public.eql_v3_real_ord_ore. ---! @param input public.eql_v3_real_ord_ore ---! @return public.eql_v3_real_ord_ore -CREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_real_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Operator wrapper for eql_v3.query_integer_ord_ope. +--! @param a eql_v3.query_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @file encrypted_domain/real/real_ord_ope_aggregates.sql ---! @brief Aggregates for public.eql_v3_real_ord_ope. +--! @brief Operator wrapper for eql_v3.query_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b eql_v3.query_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief State function for min on public.eql_v3_real_ord_ope. ---! @param state public.eql_v3_real_ord_ope ---! @param value public.eql_v3_real_ord_ope ---! @return public.eql_v3_real_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord_ope, value public.eql_v3_real_ord_ope) -RETURNS public.eql_v3_real_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Operator wrapper for eql_v3.query_integer_ord_ope. +--! @param a eql_v3.query_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief min aggregate for public.eql_v3_real_ord_ope. ---! @param input public.eql_v3_real_ord_ope ---! @return public.eql_v3_real_ord_ope -CREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_real_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); +--! @brief Operator wrapper for eql_v3.query_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b eql_v3.query_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief State function for max on public.eql_v3_real_ord_ope. ---! @param state public.eql_v3_real_ord_ope ---! @param value public.eql_v3_real_ord_ope ---! @return public.eql_v3_real_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord_ope, value public.eql_v3_real_ord_ope) -RETURNS public.eql_v3_real_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Operator wrapper for eql_v3.query_integer_ord_ope. +--! @param a eql_v3.query_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief max aggregate for public.eql_v3_real_ord_ope. ---! @param input public.eql_v3_real_ord_ope ---! @return public.eql_v3_real_ord_ope -CREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_real_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Operator wrapper for eql_v3.query_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b eql_v3.query_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @file encrypted_domain/real/real_ord_aggregates.sql ---! @brief Aggregates for public.eql_v3_real_ord. +--! @brief Operator wrapper for eql_v3.query_integer_ord_ope. +--! @param a eql_v3.query_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief State function for min on public.eql_v3_real_ord. ---! @param state public.eql_v3_real_ord ---! @param value public.eql_v3_real_ord ---! @return public.eql_v3_real_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord, value public.eql_v3_real_ord) -RETURNS public.eql_v3_real_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Operator wrapper for eql_v3.query_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b eql_v3.query_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief min aggregate for public.eql_v3_real_ord. ---! @param input public.eql_v3_real_ord ---! @return public.eql_v3_real_ord -CREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_real_ord, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); +--! @brief Operator wrapper for eql_v3.query_integer_ord_ope. +--! @param a eql_v3.query_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief State function for max on public.eql_v3_real_ord. ---! @param state public.eql_v3_real_ord ---! @param value public.eql_v3_real_ord ---! @return public.eql_v3_real_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord, value public.eql_v3_real_ord) -RETURNS public.eql_v3_real_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Operator wrapper for eql_v3.query_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b eql_v3.query_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief max aggregate for public.eql_v3_real_ord. ---! @param input public.eql_v3_real_ord ---! @return public.eql_v3_real_ord -CREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_real_ord, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); +--! @brief Operator wrapper for eql_v3.query_integer_ord_ope. +--! @param a eql_v3.query_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/real_operators.sql ---! @brief Operators for public.eql_v3_real. +--! @file encrypted_domain/integer/integer_operators.sql +--! @brief Operators for public.eql_v3_integer. CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real + LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_real, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real + LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_real, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real + LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_real, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real + LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_real, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real + LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_real, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real + LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_real, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real + LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_real, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real + LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_real, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_real, RIGHTARG = text + LEFTARG = public.eql_v3_integer, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_real, RIGHTARG = integer + LEFTARG = public.eql_v3_integer, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_real, RIGHTARG = text + LEFTARG = public.eql_v3_integer, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_real, RIGHTARG = integer + LEFTARG = public.eql_v3_integer, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_real, RIGHTARG = text + LEFTARG = public.eql_v3_integer, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_real, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_real, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_real, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_integer, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_real, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_real, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_real, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real, RIGHTARG = text + LEFTARG = public.eql_v3_integer, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real, RIGHTARG = integer + LEFTARG = public.eql_v3_integer, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_real, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real + LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_real, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/real_eq_operators.sql ---! @brief Operators for public.eql_v3_real_eq. +--! @file encrypted_domain/integer/query_integer_eq_operators.sql +--! @brief Operators for eql_v3.query_integer_eq. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq, + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = eql_v3.query_integer_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb, + LEFTARG = eql_v3.query_integer_eq, RIGHTARG = public.eql_v3_integer_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = eql_v3.query_integer_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_integer_eq, RIGHTARG = public.eql_v3_integer_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/query_integer_ord_functions.sql +--! @brief Functions for eql_v3.query_integer_ord. + +--! @brief Index extractor for eql_v3.query_integer_ord. +--! @param a eql_v3.query_integer_ord +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_integer_ord) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b eql_v3.query_integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_integer_ord. +--! @param a eql_v3.query_integer_ord +--! @param b public.eql_v3_integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b eql_v3.query_integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_integer_ord. +--! @param a eql_v3.query_integer_ord +--! @param b public.eql_v3_integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b eql_v3.query_integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_integer_ord. +--! @param a eql_v3.query_integer_ord +--! @param b public.eql_v3_integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b eql_v3.query_integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_integer_ord. +--! @param a eql_v3.query_integer_ord +--! @param b public.eql_v3_integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b eql_v3.query_integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_integer_ord. +--! @param a eql_v3.query_integer_ord +--! @param b public.eql_v3_integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b eql_v3.query_integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_integer_ord. +--! @param a eql_v3.query_integer_ord +--! @param b public.eql_v3_integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/query_integer_ord_ore_operators.sql +--! @brief Operators for eql_v3.query_integer_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq, + LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb, + LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_eq_operators.sql +--! @brief Operators for public.eql_v3_integer_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq, + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = text + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = text + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = text + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = text + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/query_real_ord_ore_operators.sql ---! @brief Operators for eql_v3.query_real_ord_ore. +--! @file encrypted_domain/integer/query_integer_ord_operators.sql +--! @brief Operators for eql_v3.query_integer_ord. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/query_real_ord_operators.sql ---! @brief Operators for eql_v3.query_real_ord. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @file encrypted_domain/integer/integer_ord_ope_aggregates.sql +--! @brief Aggregates for public.eql_v3_integer_ord_ope. -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief State function for min on public.eql_v3_integer_ord_ope. +--! @param state public.eql_v3_integer_ord_ope +--! @param value public.eql_v3_integer_ord_ope +--! @return public.eql_v3_integer_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord_ope, value public.eql_v3_integer_ord_ope) +RETURNS public.eql_v3_integer_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +--! @brief min aggregate for public.eql_v3_integer_ord_ope. +--! @param input public.eql_v3_integer_ord_ope +--! @return public.eql_v3_integer_ord_ope +CREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_integer_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe ); -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief State function for max on public.eql_v3_integer_ord_ope. +--! @param state public.eql_v3_integer_ord_ope +--! @param value public.eql_v3_integer_ord_ope +--! @return public.eql_v3_integer_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord_ope, value public.eql_v3_integer_ord_ope) +RETURNS public.eql_v3_integer_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +--! @brief max aggregate for public.eql_v3_integer_ord_ope. +--! @param input public.eql_v3_integer_ord_ope +--! @return public.eql_v3_integer_ord_ope +CREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_integer_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/query_real_ord_ope_operators.sql ---! @brief Operators for eql_v3.query_real_ord_ope. +--! @file encrypted_domain/integer/query_integer_ord_ope_operators.sql +--! @brief Operators for eql_v3.query_integer_ord_ope. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/query_real_eq_operators.sql ---! @brief Operators for eql_v3.query_real_eq. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = eql_v3.query_real_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_real_eq, RIGHTARG = public.eql_v3_real_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = eql_v3.query_real_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_real_eq, RIGHTARG = public.eql_v3_real_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); --- AUTOMATICALLY GENERATED FILE. - --! @file v3/scalars/ore_fallback.sql --! @brief Disable the ORE-backed encrypted domains when the ORE operator class is absent (CIP-3468). --! @@ -37823,2162 +40622,2623 @@ BEGIN -- must not abort). Domain coercion still enforces the CHECK on every new -- cast/insert regardless of validation status. - ALTER DOMAIN public.eql_v3_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable - 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; + ALTER DOMAIN public.eql_v3_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN eql_v3.query_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN public.eql_v3_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN eql_v3.query_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN public.eql_v3_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN eql_v3.query_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN public.eql_v3_date_ord_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN eql_v3.query_date_ord_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN public.eql_v3_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN eql_v3.query_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN public.eql_v3_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN eql_v3.query_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN public.eql_v3_text_ord_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN eql_v3.query_text_ord_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN public.eql_v3_text_search_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN eql_v3.query_text_search_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN public.eql_v3_real_ord_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN eql_v3.query_real_ord_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN public.eql_v3_double_ord_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN eql_v3.query_double_ord_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + 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'; +END; +$do$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/query_text_match_functions.sql +--! @brief Functions for eql_v3.query_text_match. + +--! @brief Index extractor for eql_v3.query_text_match. +--! @param a eql_v3.query_text_match +--! @return eql_v3_internal.bloom_filter +CREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_match) +RETURNS eql_v3_internal.bloom_filter +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_text_match. +--! @param a public.eql_v3_text_match +--! @param b eql_v3.query_text_match +--! @return boolean +CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b eql_v3.query_text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_match. +--! @param a eql_v3.query_text_match +--! @param b public.eql_v3_text_match +--! @return boolean +CREATE FUNCTION eql_v3.matches(a eql_v3.query_text_match, b public.eql_v3_text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_functions.sql +--! @brief Functions for public.eql_v3_text. + +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a jsonb +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a jsonb +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a jsonb +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a jsonb +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a jsonb +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN eql_v3.query_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN public.eql_v3_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a jsonb +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN eql_v3.query_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN public.eql_v3_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN eql_v3.query_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a jsonb +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN public.eql_v3_date_ord_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN eql_v3.query_date_ord_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN public.eql_v3_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a jsonb +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN eql_v3.query_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param selector text +--! @return public.eql_v3_text +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text, selector text) +RETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN public.eql_v3_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param selector integer +--! @return public.eql_v3_text +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text, selector integer) +RETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN eql_v3.query_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a jsonb +--! @param selector public.eql_v3_text +--! @return public.eql_v3_text +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text) +RETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN public.eql_v3_text_ord_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN eql_v3.query_text_ord_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN public.eql_v3_text_search_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a jsonb +--! @param selector public.eql_v3_text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN eql_v3.query_text_search_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN public.eql_v3_real_ord_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN eql_v3.query_real_ord_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN public.eql_v3_double_ord_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN eql_v3.query_double_ord_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - 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'; -END; -$do$; --- AUTOMATICALLY GENERATED FILE. +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; ---! @file encrypted_domain/numeric/query_numeric_ord_ore_operators.sql ---! @brief Operators for eql_v3.query_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a jsonb +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b public.eql_v3_text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text, b public.eql_v3_text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a jsonb +--! @param b public.eql_v3_text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @file encrypted_domain/text/query_text_ord_ope_functions.sql +--! @brief Functions for eql_v3.query_text_ord_ope. -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Index extractor for eql_v3.query_text_ord_ope. +--! @param a eql_v3.query_text_ord_ope +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord_ope) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @file encrypted_domain/numeric/query_numeric_ord_operators.sql ---! @brief Operators for eql_v3.query_numeric_ord. +--! @brief Index extractor for eql_v3.query_text_ord_ope. +--! @param a eql_v3.query_text_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b eql_v3.query_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord_ope. +--! @param a eql_v3.query_text_ord_ope +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b eql_v3.query_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord_ope. +--! @param a eql_v3.query_text_ord_ope +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b eql_v3.query_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord_ope. +--! @param a eql_v3.query_text_ord_ope +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b eql_v3.query_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord_ope. +--! @param a eql_v3.query_text_ord_ope +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b eql_v3.query_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord_ope. +--! @param a eql_v3.query_text_ord_ope +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b eql_v3.query_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord_ope. +--! @param a eql_v3.query_text_ord_ope +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/numeric/query_numeric_ord_ope_operators.sql ---! @brief Operators for eql_v3.query_numeric_ord_ope. +--! @file encrypted_domain/text/query_text_ord_operators.sql +--! @brief Operators for eql_v3.query_text_ord. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/numeric/query_numeric_eq_operators.sql ---! @brief Operators for eql_v3.query_numeric_eq. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = eql_v3.query_numeric_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = eql_v3.query_numeric_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_ord_ore_aggregates.sql ---! @brief Aggregates for public.eql_v3_numeric_ord_ore. - ---! @brief State function for min on public.eql_v3_numeric_ord_ore. ---! @param state public.eql_v3_numeric_ord_ore ---! @param value public.eql_v3_numeric_ord_ore ---! @return public.eql_v3_numeric_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord_ore, value public.eql_v3_numeric_ord_ore) -RETURNS public.eql_v3_numeric_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for public.eql_v3_numeric_ord_ore. ---! @param input public.eql_v3_numeric_ord_ore ---! @return public.eql_v3_numeric_ord_ore -CREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_numeric_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on public.eql_v3_numeric_ord_ore. ---! @param state public.eql_v3_numeric_ord_ore ---! @param value public.eql_v3_numeric_ord_ore ---! @return public.eql_v3_numeric_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord_ore, value public.eql_v3_numeric_ord_ore) -RETURNS public.eql_v3_numeric_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for public.eql_v3_numeric_ord_ore. ---! @param input public.eql_v3_numeric_ord_ore ---! @return public.eql_v3_numeric_ord_ore -CREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_numeric_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_ord_ope_aggregates.sql ---! @brief Aggregates for public.eql_v3_numeric_ord_ope. - ---! @brief State function for min on public.eql_v3_numeric_ord_ope. ---! @param state public.eql_v3_numeric_ord_ope ---! @param value public.eql_v3_numeric_ord_ope ---! @return public.eql_v3_numeric_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord_ope, value public.eql_v3_numeric_ord_ope) -RETURNS public.eql_v3_numeric_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for public.eql_v3_numeric_ord_ope. ---! @param input public.eql_v3_numeric_ord_ope ---! @return public.eql_v3_numeric_ord_ope -CREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_numeric_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on public.eql_v3_numeric_ord_ope. ---! @param state public.eql_v3_numeric_ord_ope ---! @param value public.eql_v3_numeric_ord_ope ---! @return public.eql_v3_numeric_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord_ope, value public.eql_v3_numeric_ord_ope) -RETURNS public.eql_v3_numeric_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for public.eql_v3_numeric_ord_ope. ---! @param input public.eql_v3_numeric_ord_ope ---! @return public.eql_v3_numeric_ord_ope -CREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_numeric_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. +--! @file encrypted_domain/text/query_text_eq_functions.sql +--! @brief Functions for eql_v3.query_text_eq. ---! @file encrypted_domain/numeric/numeric_ord_aggregates.sql ---! @brief Aggregates for public.eql_v3_numeric_ord. +--! @brief Index extractor for eql_v3.query_text_eq. +--! @param a eql_v3.query_text_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief State function for min on public.eql_v3_numeric_ord. ---! @param state public.eql_v3_numeric_ord ---! @param value public.eql_v3_numeric_ord ---! @return public.eql_v3_numeric_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord, value public.eql_v3_numeric_ord) -RETURNS public.eql_v3_numeric_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Operator wrapper for eql_v3.query_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b eql_v3.query_text_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b eql_v3.query_text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief min aggregate for public.eql_v3_numeric_ord. ---! @param input public.eql_v3_numeric_ord ---! @return public.eql_v3_numeric_ord -CREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_numeric_ord, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); +--! @brief Operator wrapper for eql_v3.query_text_eq. +--! @param a eql_v3.query_text_eq +--! @param b public.eql_v3_text_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_eq, b public.eql_v3_text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief State function for max on public.eql_v3_numeric_ord. ---! @param state public.eql_v3_numeric_ord ---! @param value public.eql_v3_numeric_ord ---! @return public.eql_v3_numeric_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord, value public.eql_v3_numeric_ord) -RETURNS public.eql_v3_numeric_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Operator wrapper for eql_v3.query_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b eql_v3.query_text_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b eql_v3.query_text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief max aggregate for public.eql_v3_numeric_ord. ---! @param input public.eql_v3_numeric_ord ---! @return public.eql_v3_numeric_ord -CREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_numeric_ord, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); +--! @brief Operator wrapper for eql_v3.query_text_eq. +--! @param a eql_v3.query_text_eq +--! @param b public.eql_v3_text_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_eq, b public.eql_v3_text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/numeric/numeric_operators.sql ---! @brief Operators for public.eql_v3_numeric. - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric -); +--! @file encrypted_domain/text/text_match_operators.sql +--! @brief Operators for public.eql_v3_text_match. CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_numeric, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_numeric, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_numeric, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_numeric, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_numeric, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_numeric, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_numeric, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_numeric, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_numeric, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_numeric, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_eq_operators.sql ---! @brief Operators for public.eql_v3_numeric_eq. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb ); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq + LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq + LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq + LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq + LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq + LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq + LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text + LEFTARG = public.eql_v3_text_match, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_text_match, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text + LEFTARG = public.eql_v3_text_match, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_text_match, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text + LEFTARG = public.eql_v3_text_match, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_match, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_match, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match, + RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb, + RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match, + RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_match, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_match, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text + LEFTARG = public.eql_v3_text_match, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_text_match, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_match, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_match, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq + LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/integer/query_integer_ord_ore_operators.sql ---! @brief Operators for eql_v3.query_integer_ord_ore. +--! @file encrypted_domain/text/text_search_operators.sql +--! @brief Operators for public.eql_v3_text_search. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore, + LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore, + LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore, + LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore, + LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore, + LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore, + LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/integer/query_integer_ord_operators.sql ---! @brief Operators for eql_v3.query_integer_ord. -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search ); -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb ); -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search ); -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search ); -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb ); -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search ); -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_text_search, RIGHTARG = text ); -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_text_search, RIGHTARG = integer ); -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search ); -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_text_search, RIGHTARG = text ); -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_text_search, RIGHTARG = integer ); --- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/integer/query_integer_ord_ope_operators.sql ---! @brief Operators for eql_v3.query_integer_ord_ope. +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search +); -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_text_search, RIGHTARG = text ); -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_text_search, RIGHTARG = text[] ); -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_text_search, RIGHTARG = text[] ); -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonpath ); -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, + RESTRICT = contsel, JOIN = contjoinsel ); -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, + RESTRICT = contsel, JOIN = contjoinsel ); -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, + RESTRICT = contsel, JOIN = contjoinsel ); -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonpath ); -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_text_search, RIGHTARG = text[] ); -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_text_search, RIGHTARG = text[] ); -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_text_search, RIGHTARG = text ); -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_text_search, RIGHTARG = integer ); --- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/integer/query_integer_eq_operators.sql ---! @brief Operators for eql_v3.query_integer_eq. +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_text_search, RIGHTARG = text[] +); -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = eql_v3.query_integer_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_text_search, RIGHTARG = text[] ); -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_integer_eq, RIGHTARG = public.eql_v3_integer_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search ); -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = eql_v3.query_integer_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb ); -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_integer_eq, RIGHTARG = public.eql_v3_integer_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/integer/integer_ord_ore_aggregates.sql ---! @brief Aggregates for public.eql_v3_integer_ord_ore. +--! @file encrypted_domain/text/query_text_search_ore_functions.sql +--! @brief Functions for eql_v3.query_text_search_ore. + +--! @brief Index extractor for eql_v3.query_text_search_ore. +--! @param a eql_v3.query_text_search_ore +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_search_ore) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Index extractor for eql_v3.query_text_search_ore. +--! @param a eql_v3.query_text_search_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_text_search_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Index extractor for eql_v3.query_text_search_ore. +--! @param a eql_v3.query_text_search_ore +--! @return eql_v3_internal.bloom_filter +CREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_search_ore) +RETURNS eql_v3_internal.bloom_filter +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b eql_v3.query_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a eql_v3.query_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b eql_v3.query_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a eql_v3.query_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b eql_v3.query_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a eql_v3.query_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b eql_v3.query_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a eql_v3.query_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b eql_v3.query_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a eql_v3.query_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b eql_v3.query_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a eql_v3.query_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b eql_v3.query_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a eql_v3.query_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.matches(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/query_text_ord_ore_functions.sql +--! @brief Functions for eql_v3.query_text_ord_ore. ---! @brief State function for min on public.eql_v3_integer_ord_ore. ---! @param state public.eql_v3_integer_ord_ore ---! @param value public.eql_v3_integer_ord_ore ---! @return public.eql_v3_integer_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord_ore, value public.eql_v3_integer_ord_ore) -RETURNS public.eql_v3_integer_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Index extractor for eql_v3.query_text_ord_ore. +--! @param a eql_v3.query_text_ord_ore +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord_ore) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief min aggregate for public.eql_v3_integer_ord_ore. ---! @param input public.eql_v3_integer_ord_ore ---! @return public.eql_v3_integer_ord_ore -CREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_integer_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); +--! @brief Index extractor for eql_v3.query_text_ord_ore. +--! @param a eql_v3.query_text_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_text_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; ---! @brief State function for max on public.eql_v3_integer_ord_ore. ---! @param state public.eql_v3_integer_ord_ore ---! @param value public.eql_v3_integer_ord_ore ---! @return public.eql_v3_integer_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord_ore, value public.eql_v3_integer_ord_ore) -RETURNS public.eql_v3_integer_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Operator wrapper for eql_v3.query_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b eql_v3.query_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief max aggregate for public.eql_v3_integer_ord_ore. ---! @param input public.eql_v3_integer_ord_ore ---! @return public.eql_v3_integer_ord_ore -CREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_integer_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Operator wrapper for eql_v3.query_text_ord_ore. +--! @param a eql_v3.query_text_ord_ore +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @file encrypted_domain/integer/integer_ord_ope_aggregates.sql ---! @brief Aggregates for public.eql_v3_integer_ord_ope. +--! @brief Operator wrapper for eql_v3.query_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b eql_v3.query_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief State function for min on public.eql_v3_integer_ord_ope. ---! @param state public.eql_v3_integer_ord_ope ---! @param value public.eql_v3_integer_ord_ope ---! @return public.eql_v3_integer_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord_ope, value public.eql_v3_integer_ord_ope) -RETURNS public.eql_v3_integer_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Operator wrapper for eql_v3.query_text_ord_ore. +--! @param a eql_v3.query_text_ord_ore +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief min aggregate for public.eql_v3_integer_ord_ope. ---! @param input public.eql_v3_integer_ord_ope ---! @return public.eql_v3_integer_ord_ope -CREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_integer_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); +--! @brief Operator wrapper for eql_v3.query_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b eql_v3.query_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief State function for max on public.eql_v3_integer_ord_ope. ---! @param state public.eql_v3_integer_ord_ope ---! @param value public.eql_v3_integer_ord_ope ---! @return public.eql_v3_integer_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord_ope, value public.eql_v3_integer_ord_ope) -RETURNS public.eql_v3_integer_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Operator wrapper for eql_v3.query_text_ord_ore. +--! @param a eql_v3.query_text_ord_ore +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief max aggregate for public.eql_v3_integer_ord_ope. ---! @param input public.eql_v3_integer_ord_ope ---! @return public.eql_v3_integer_ord_ope -CREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_integer_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Operator wrapper for eql_v3.query_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b eql_v3.query_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @file encrypted_domain/integer/integer_ord_aggregates.sql ---! @brief Aggregates for public.eql_v3_integer_ord. +--! @brief Operator wrapper for eql_v3.query_text_ord_ore. +--! @param a eql_v3.query_text_ord_ore +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief State function for min on public.eql_v3_integer_ord. ---! @param state public.eql_v3_integer_ord ---! @param value public.eql_v3_integer_ord ---! @return public.eql_v3_integer_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord, value public.eql_v3_integer_ord) -RETURNS public.eql_v3_integer_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Operator wrapper for eql_v3.query_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b eql_v3.query_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief min aggregate for public.eql_v3_integer_ord. ---! @param input public.eql_v3_integer_ord ---! @return public.eql_v3_integer_ord -CREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_integer_ord, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); +--! @brief Operator wrapper for eql_v3.query_text_ord_ore. +--! @param a eql_v3.query_text_ord_ore +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief State function for max on public.eql_v3_integer_ord. ---! @param state public.eql_v3_integer_ord ---! @param value public.eql_v3_integer_ord ---! @return public.eql_v3_integer_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord, value public.eql_v3_integer_ord) -RETURNS public.eql_v3_integer_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Operator wrapper for eql_v3.query_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b eql_v3.query_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; ---! @brief max aggregate for public.eql_v3_integer_ord. ---! @param input public.eql_v3_integer_ord ---! @return public.eql_v3_integer_ord -CREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_integer_ord, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); +--! @brief Operator wrapper for eql_v3.query_text_ord_ore. +--! @param a eql_v3.query_text_ord_ore +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/integer/integer_operators.sql ---! @brief Operators for public.eql_v3_integer. +--! @file encrypted_domain/text/text_search_ore_operators.sql +--! @brief Operators for public.eql_v3_text_search_ore. CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_integer, RIGHTARG = text + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_integer, RIGHTARG = integer + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_integer, RIGHTARG = text + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_integer, RIGHTARG = integer + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_integer, RIGHTARG = text + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_integer, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_integer, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_integer, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, + RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, + RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_integer, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_integer, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore ); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/query_text_search_functions.sql +--! @brief Functions for eql_v3.query_text_search. + +--! @brief Index extractor for eql_v3.query_text_search. +--! @param a eql_v3.query_text_search +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_search) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Index extractor for eql_v3.query_text_search. +--! @param a eql_v3.query_text_search +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_search) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Index extractor for eql_v3.query_text_search. +--! @param a eql_v3.query_text_search +--! @return eql_v3_internal.bloom_filter +CREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_search) +RETURNS eql_v3_internal.bloom_filter +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a public.eql_v3_text_search +--! @param b eql_v3.query_text_search +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b eql_v3.query_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a eql_v3.query_text_search +--! @param b public.eql_v3_text_search +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_search, b public.eql_v3_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a public.eql_v3_text_search +--! @param b eql_v3.query_text_search +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b eql_v3.query_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a eql_v3.query_text_search +--! @param b public.eql_v3_text_search +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_search, b public.eql_v3_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a public.eql_v3_text_search +--! @param b eql_v3.query_text_search +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b eql_v3.query_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a eql_v3.query_text_search +--! @param b public.eql_v3_text_search +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_search, b public.eql_v3_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_integer, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a public.eql_v3_text_search +--! @param b eql_v3.query_text_search +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b eql_v3.query_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer, RIGHTARG = text -); +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a eql_v3.query_text_search +--! @param b public.eql_v3_text_search +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_search, b public.eql_v3_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer, RIGHTARG = integer -); +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a public.eql_v3_text_search +--! @param b eql_v3.query_text_search +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b eql_v3.query_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a eql_v3.query_text_search +--! @param b public.eql_v3_text_search +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_search, b public.eql_v3_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_integer, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a public.eql_v3_text_search +--! @param b eql_v3.query_text_search +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b eql_v3.query_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer -); +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a eql_v3.query_text_search +--! @param b public.eql_v3_text_search +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_search, b public.eql_v3_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb -); +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a public.eql_v3_text_search +--! @param b eql_v3.query_text_search +--! @return boolean +CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b eql_v3.query_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer -); +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a eql_v3.query_text_search +--! @param b public.eql_v3_text_search +--! @return boolean +CREATE FUNCTION eql_v3.matches(a eql_v3.query_text_search, b public.eql_v3_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/integer/integer_eq_operators.sql ---! @brief Operators for public.eql_v3_integer_eq. +--! @file encrypted_domain/text/text_eq_operators.sql +--! @brief Operators for public.eql_v3_text_eq. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq, + LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq, + LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq + LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq + LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq + LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq + LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq + LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq + LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text + LEFTARG = public.eql_v3_text_eq, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text + LEFTARG = public.eql_v3_text_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text + LEFTARG = public.eql_v3_text_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text + LEFTARG = public.eql_v3_text_eq, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq + LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/query_double_ord_ore_operators.sql ---! @brief Operators for eql_v3.query_double_ord_ore. +--! @file encrypted_domain/text/text_ord_ore_aggregates.sql +--! @brief Aggregates for public.eql_v3_text_ord_ore. + +--! @brief State function for min on public.eql_v3_text_ord_ore. +--! @param state public.eql_v3_text_ord_ore +--! @param value public.eql_v3_text_ord_ore +--! @return public.eql_v3_text_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord_ore, value public.eql_v3_text_ord_ore) +RETURNS public.eql_v3_text_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.eql_v3_text_ord_ore. +--! @param input public.eql_v3_text_ord_ore +--! @return public.eql_v3_text_ord_ore +CREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_text_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.eql_v3_text_ord_ore. +--! @param state public.eql_v3_text_ord_ore +--! @param value public.eql_v3_text_ord_ore +--! @return public.eql_v3_text_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord_ore, value public.eql_v3_text_ord_ore) +RETURNS public.eql_v3_text_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.eql_v3_text_ord_ore. +--! @param input public.eql_v3_text_ord_ore +--! @return public.eql_v3_text_ord_ore +CREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_text_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_aggregates.sql +--! @brief Aggregates for public.eql_v3_text_ord. + +--! @brief State function for min on public.eql_v3_text_ord. +--! @param state public.eql_v3_text_ord +--! @param value public.eql_v3_text_ord +--! @return public.eql_v3_text_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord, value public.eql_v3_text_ord) +RETURNS public.eql_v3_text_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.eql_v3_text_ord. +--! @param input public.eql_v3_text_ord +--! @return public.eql_v3_text_ord +CREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_text_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.eql_v3_text_ord. +--! @param state public.eql_v3_text_ord +--! @param value public.eql_v3_text_ord +--! @return public.eql_v3_text_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord, value public.eql_v3_text_ord) +RETURNS public.eql_v3_text_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.eql_v3_text_ord. +--! @param input public.eql_v3_text_ord +--! @return public.eql_v3_text_ord +CREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_text_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/query_text_ord_ope_operators.sql +--! @brief Operators for eql_v3.query_text_ord_ope. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/query_double_ord_operators.sql ---! @brief Operators for eql_v3.query_double_ord. +--! @file encrypted_domain/text/text_ord_ope_operators.sql +--! @brief Operators for public.eql_v3_text_ord_ope. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); --- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/query_double_ord_ope_operators.sql ---! @brief Operators for eql_v3.query_double_ord_ope. +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope ); -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb ); -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope ); -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope ); -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb ); -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope ); -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text ); -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer ); -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope ); -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope ); -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb ); -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope ); --- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/query_double_eq_operators.sql ---! @brief Operators for eql_v3.query_double_eq. +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonpath +); -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = eql_v3.query_double_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[] ); -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_double_eq, RIGHTARG = public.eql_v3_double_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[] ); -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = eql_v3.query_double_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text ); -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_double_eq, RIGHTARG = public.eql_v3_double_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer ); --- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/double_ord_ore_aggregates.sql ---! @brief Aggregates for public.eql_v3_double_ord_ore. +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[] +); ---! @brief State function for min on public.eql_v3_double_ord_ore. ---! @param state public.eql_v3_double_ord_ore ---! @param value public.eql_v3_double_ord_ore ---! @return public.eql_v3_double_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord_ore, value public.eql_v3_double_ord_ore) -RETURNS public.eql_v3_double_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[] +); ---! @brief min aggregate for public.eql_v3_double_ord_ore. ---! @param input public.eql_v3_double_ord_ore ---! @return public.eql_v3_double_ord_ore -CREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_double_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope ); ---! @brief State function for max on public.eql_v3_double_ord_ore. ---! @param state public.eql_v3_double_ord_ore ---! @param value public.eql_v3_double_ord_ore ---! @return public.eql_v3_double_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord_ore, value public.eql_v3_double_ord_ore) -RETURNS public.eql_v3_double_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb +); ---! @brief max aggregate for public.eql_v3_double_ord_ore. ---! @param input public.eql_v3_double_ord_ore ---! @return public.eql_v3_double_ord_ore -CREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_double_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/double_ord_ope_aggregates.sql ---! @brief Aggregates for public.eql_v3_double_ord_ope. +--! @file encrypted_domain/text/text_ord_ope_aggregates.sql +--! @brief Aggregates for public.eql_v3_text_ord_ope. ---! @brief State function for min on public.eql_v3_double_ord_ope. ---! @param state public.eql_v3_double_ord_ope ---! @param value public.eql_v3_double_ord_ope ---! @return public.eql_v3_double_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord_ope, value public.eql_v3_double_ord_ope) -RETURNS public.eql_v3_double_ord_ope +--! @brief State function for min on public.eql_v3_text_ord_ope. +--! @param state public.eql_v3_text_ord_ope +--! @param value public.eql_v3_text_ord_ope +--! @return public.eql_v3_text_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord_ope, value public.eql_v3_text_ord_ope) +RETURNS public.eql_v3_text_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -39990,22 +43250,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_double_ord_ope. ---! @param input public.eql_v3_double_ord_ope ---! @return public.eql_v3_double_ord_ope -CREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord_ope) ( +--! @brief min aggregate for public.eql_v3_text_ord_ope. +--! @param input public.eql_v3_text_ord_ope +--! @return public.eql_v3_text_ord_ope +CREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord_ope) ( sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_double_ord_ope, + stype = public.eql_v3_text_ord_ope, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_double_ord_ope. ---! @param state public.eql_v3_double_ord_ope ---! @param value public.eql_v3_double_ord_ope ---! @return public.eql_v3_double_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord_ope, value public.eql_v3_double_ord_ope) -RETURNS public.eql_v3_double_ord_ope +--! @brief State function for max on public.eql_v3_text_ord_ope. +--! @param state public.eql_v3_text_ord_ope +--! @param value public.eql_v3_text_ord_ope +--! @return public.eql_v3_text_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord_ope, value public.eql_v3_text_ord_ope) +RETURNS public.eql_v3_text_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -40017,910 +43277,1104 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_double_ord_ope. ---! @param input public.eql_v3_double_ord_ope ---! @return public.eql_v3_double_ord_ope -CREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord_ope) ( +--! @brief max aggregate for public.eql_v3_text_ord_ope. +--! @param input public.eql_v3_text_ord_ope +--! @return public.eql_v3_text_ord_ope +CREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord_ope) ( sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_double_ord_ope, + stype = public.eql_v3_text_ord_ope, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/double_ord_aggregates.sql ---! @brief Aggregates for public.eql_v3_double_ord. - ---! @brief State function for min on public.eql_v3_double_ord. ---! @param state public.eql_v3_double_ord ---! @param value public.eql_v3_double_ord ---! @return public.eql_v3_double_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord, value public.eql_v3_double_ord) -RETURNS public.eql_v3_double_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @file encrypted_domain/text/query_text_match_operators.sql +--! @brief Operators for eql_v3.query_text_match. ---! @brief min aggregate for public.eql_v3_double_ord. ---! @param input public.eql_v3_double_ord ---! @return public.eql_v3_double_ord -CREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_double_ord, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = public.eql_v3_text_match, RIGHTARG = eql_v3.query_text_match, + RESTRICT = contsel, JOIN = contjoinsel ); ---! @brief State function for max on public.eql_v3_double_ord. ---! @param state public.eql_v3_double_ord ---! @param value public.eql_v3_double_ord ---! @return public.eql_v3_double_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord, value public.eql_v3_double_ord) -RETURNS public.eql_v3_double_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for public.eql_v3_double_ord. ---! @param input public.eql_v3_double_ord ---! @return public.eql_v3_double_ord -CREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_double_ord, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = eql_v3.query_text_match, RIGHTARG = public.eql_v3_text_match, + RESTRICT = contsel, JOIN = contjoinsel ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/double_operators.sql ---! @brief Operators for public.eql_v3_double. +--! @file encrypted_domain/text/text_operators.sql +--! @brief Operators for public.eql_v3_text. CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double + LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_double, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text, RIGHTARG = jsonb ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double + LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_double, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text, RIGHTARG = jsonb ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double + LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_double, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double + LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_double, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double + LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_double, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double + LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_double, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double + LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_double, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double + LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_double, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_double, RIGHTARG = text + LEFTARG = public.eql_v3_text, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_double, RIGHTARG = integer + LEFTARG = public.eql_v3_text, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_double, RIGHTARG = text + LEFTARG = public.eql_v3_text, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_double, RIGHTARG = integer + LEFTARG = public.eql_v3_text, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_double, RIGHTARG = text + LEFTARG = public.eql_v3_text, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_double, RIGHTARG = text[] + LEFTARG = public.eql_v3_text, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_double, RIGHTARG = text[] + LEFTARG = public.eql_v3_text, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_double, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_text, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_double, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_double, RIGHTARG = text[] + LEFTARG = public.eql_v3_text, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_double, RIGHTARG = text[] + LEFTARG = public.eql_v3_text, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double, RIGHTARG = text + LEFTARG = public.eql_v3_text, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double, RIGHTARG = integer + LEFTARG = public.eql_v3_text, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double, RIGHTARG = text[] + LEFTARG = public.eql_v3_text, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_double, RIGHTARG = text[] + LEFTARG = public.eql_v3_text, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double + LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_double, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/double_eq_operators.sql ---! @brief Operators for public.eql_v3_double_eq. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq -); +--! @file encrypted_domain/text/text_search_aggregates.sql +--! @brief Aggregates for public.eql_v3_text_search. -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq -); +--! @brief State function for min on public.eql_v3_text_search. +--! @param state public.eql_v3_text_search +--! @param value public.eql_v3_text_search +--! @return public.eql_v3_text_search +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_search, value public.eql_v3_text_search) +RETURNS public.eql_v3_text_search +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb +--! @brief min aggregate for public.eql_v3_text_search. +--! @param input public.eql_v3_text_search +--! @return public.eql_v3_text_search +CREATE AGGREGATE eql_v3.min(public.eql_v3_text_search) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_text_search, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe ); -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq -); +--! @brief State function for max on public.eql_v3_text_search. +--! @param state public.eql_v3_text_search +--! @param value public.eql_v3_text_search +--! @return public.eql_v3_text_search +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_search, value public.eql_v3_text_search) +RETURNS public.eql_v3_text_search +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq +--! @brief max aggregate for public.eql_v3_text_search. +--! @param input public.eql_v3_text_search +--! @return public.eql_v3_text_search +CREATE AGGREGATE eql_v3.max(public.eql_v3_text_search) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_text_search, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe ); +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb -); +--! @file encrypted_domain/text/text_search_ore_aggregates.sql +--! @brief Aggregates for public.eql_v3_text_search_ore. -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq -); +--! @brief State function for min on public.eql_v3_text_search_ore. +--! @param state public.eql_v3_text_search_ore +--! @param value public.eql_v3_text_search_ore +--! @return public.eql_v3_text_search_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_search_ore, value public.eql_v3_text_search_ore) +RETURNS public.eql_v3_text_search_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq +--! @brief min aggregate for public.eql_v3_text_search_ore. +--! @param input public.eql_v3_text_search_ore +--! @return public.eql_v3_text_search_ore +CREATE AGGREGATE eql_v3.min(public.eql_v3_text_search_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_text_search_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe ); -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb -); +--! @brief State function for max on public.eql_v3_text_search_ore. +--! @param state public.eql_v3_text_search_ore +--! @param value public.eql_v3_text_search_ore +--! @return public.eql_v3_text_search_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_search_ore, value public.eql_v3_text_search_ore) +RETURNS public.eql_v3_text_search_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq +--! @brief max aggregate for public.eql_v3_text_search_ore. +--! @param input public.eql_v3_text_search_ore +--! @return public.eql_v3_text_search_ore +CREATE AGGREGATE eql_v3.max(public.eql_v3_text_search_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_text_search_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe ); +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = text -); +--! @file encrypted_domain/text/query_text_search_operators.sql +--! @brief Operators for eql_v3.query_text_search. -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = text +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = text +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[] +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[] +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonpath +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonpath +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[] +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[] +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = text +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + RESTRICT = contsel, JOIN = contjoinsel ); -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + RESTRICT = contsel, JOIN = contjoinsel ); +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[] -); +--! @file encrypted_domain/text/query_text_eq_operators.sql +--! @brief Operators for eql_v3.query_text_eq. -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[] +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_text_eq, RIGHTARG = eql_v3.query_text_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_text_eq, RIGHTARG = public.eql_v3_text_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_text_eq, RIGHTARG = eql_v3.query_text_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_text_eq, RIGHTARG = public.eql_v3_text_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/query_date_ord_ore_operators.sql ---! @brief Operators for eql_v3.query_date_ord_ore. +--! @file encrypted_domain/text/query_text_ord_ore_operators.sql +--! @brief Operators for eql_v3.query_text_ord_ore. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/query_date_ord_operators.sql ---! @brief Operators for eql_v3.query_date_ord. +--! @file encrypted_domain/text/query_text_search_ore_operators.sql +--! @brief Operators for eql_v3.query_text_search_ore. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord, + LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord, + LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord, + LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord, + LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord, + LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord, + LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/date/query_date_ord_ope_operators.sql ---! @brief Operators for eql_v3.query_date_ord_ope. -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, + RESTRICT = contsel, JOIN = contjoinsel ); -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + RESTRICT = contsel, JOIN = contjoinsel ); +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @file encrypted_domain/timestamp/timestamp_functions.sql +--! @brief Functions for public.eql_v3_timestamp. -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b public.eql_v3_timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a jsonb +--! @param b public.eql_v3_timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b public.eql_v3_timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a jsonb +--! @param b public.eql_v3_timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b public.eql_v3_timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a jsonb +--! @param b public.eql_v3_timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b public.eql_v3_timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a jsonb +--! @param b public.eql_v3_timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b public.eql_v3_timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a jsonb +--! @param b public.eql_v3_timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b public.eql_v3_timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a jsonb +--! @param b public.eql_v3_timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b public.eql_v3_timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a jsonb +--! @param b public.eql_v3_timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b public.eql_v3_timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a jsonb +--! @param b public.eql_v3_timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param selector text +--! @return public.eql_v3_timestamp +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp, selector text) +RETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param selector integer +--! @return public.eql_v3_timestamp +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp, selector integer) +RETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a jsonb +--! @param selector public.eql_v3_timestamp +--! @return public.eql_v3_timestamp +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp) +RETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a jsonb +--! @param selector public.eql_v3_timestamp +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; ---! @file encrypted_domain/date/query_date_eq_operators.sql ---! @brief Operators for eql_v3.query_date_eq. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = eql_v3.query_date_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_date_eq, RIGHTARG = public.eql_v3_date_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b public.eql_v3_timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = eql_v3.query_date_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_date_eq, RIGHTARG = public.eql_v3_date_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a jsonb +--! @param b public.eql_v3_timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; ---! @file encrypted_domain/date/date_ord_ore_aggregates.sql ---! @brief Aggregates for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; ---! @brief State function for min on public.eql_v3_date_ord_ore. ---! @param state public.eql_v3_date_ord_ore ---! @param value public.eql_v3_date_ord_ore ---! @return public.eql_v3_date_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord_ore, value public.eql_v3_date_ord_ore) -RETURNS public.eql_v3_date_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; ---! @brief min aggregate for public.eql_v3_date_ord_ore. ---! @param input public.eql_v3_date_ord_ore ---! @return public.eql_v3_date_ord_ore -CREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_date_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; ---! @brief State function for max on public.eql_v3_date_ord_ore. ---! @param state public.eql_v3_date_ord_ore ---! @param value public.eql_v3_date_ord_ore ---! @return public.eql_v3_date_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord_ore, value public.eql_v3_date_ord_ore) -RETURNS public.eql_v3_date_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; ---! @brief max aggregate for public.eql_v3_date_ord_ore. ---! @param input public.eql_v3_date_ord_ore ---! @return public.eql_v3_date_ord_ore -CREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_date_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; ---! @file encrypted_domain/date/date_ord_ope_aggregates.sql ---! @brief Aggregates for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; ---! @brief State function for min on public.eql_v3_date_ord_ope. ---! @param state public.eql_v3_date_ord_ope ---! @param value public.eql_v3_date_ord_ope ---! @return public.eql_v3_date_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord_ope, value public.eql_v3_date_ord_ope) -RETURNS public.eql_v3_date_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; ---! @brief min aggregate for public.eql_v3_date_ord_ope. ---! @param input public.eql_v3_date_ord_ope ---! @return public.eql_v3_date_ord_ope -CREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_date_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b public.eql_v3_timestamp +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; ---! @brief State function for max on public.eql_v3_date_ord_ope. ---! @param state public.eql_v3_date_ord_ope ---! @param value public.eql_v3_date_ord_ope ---! @return public.eql_v3_date_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord_ope, value public.eql_v3_date_ord_ope) -RETURNS public.eql_v3_date_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; ---! @brief max aggregate for public.eql_v3_date_ord_ope. ---! @param input public.eql_v3_date_ord_ope ---! @return public.eql_v3_date_ord_ope -CREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_date_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a jsonb +--! @param b public.eql_v3_timestamp +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/date_ord_aggregates.sql ---! @brief Aggregates for public.eql_v3_date_ord. +--! @file encrypted_domain/timestamp/timestamp_ord_aggregates.sql +--! @brief Aggregates for public.eql_v3_timestamp_ord. ---! @brief State function for min on public.eql_v3_date_ord. ---! @param state public.eql_v3_date_ord ---! @param value public.eql_v3_date_ord ---! @return public.eql_v3_date_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord, value public.eql_v3_date_ord) -RETURNS public.eql_v3_date_ord +--! @brief State function for min on public.eql_v3_timestamp_ord. +--! @param state public.eql_v3_timestamp_ord +--! @param value public.eql_v3_timestamp_ord +--! @return public.eql_v3_timestamp_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord, value public.eql_v3_timestamp_ord) +RETURNS public.eql_v3_timestamp_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -40932,22 +44386,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_date_ord. ---! @param input public.eql_v3_date_ord ---! @return public.eql_v3_date_ord -CREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord) ( +--! @brief min aggregate for public.eql_v3_timestamp_ord. +--! @param input public.eql_v3_timestamp_ord +--! @return public.eql_v3_timestamp_ord +CREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord) ( sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_date_ord, + stype = public.eql_v3_timestamp_ord, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_date_ord. ---! @param state public.eql_v3_date_ord ---! @param value public.eql_v3_date_ord ---! @return public.eql_v3_date_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord, value public.eql_v3_date_ord) -RETURNS public.eql_v3_date_ord +--! @brief State function for max on public.eql_v3_timestamp_ord. +--! @param state public.eql_v3_timestamp_ord +--! @param value public.eql_v3_timestamp_ord +--! @return public.eql_v3_timestamp_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord, value public.eql_v3_timestamp_ord) +RETURNS public.eql_v3_timestamp_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -40959,1076 +44413,757 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_date_ord. ---! @param input public.eql_v3_date_ord ---! @return public.eql_v3_date_ord -CREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord) ( +--! @brief max aggregate for public.eql_v3_timestamp_ord. +--! @param input public.eql_v3_timestamp_ord +--! @return public.eql_v3_timestamp_ord +CREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord) ( sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_date_ord, + stype = public.eql_v3_timestamp_ord, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/date_operators.sql ---! @brief Operators for public.eql_v3_date. - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_date, RIGHTARG = jsonb -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_date, RIGHTARG = jsonb -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_date, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_date, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_date, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_date, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_date, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_date, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_date, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_date, RIGHTARG = integer -); +--! @file encrypted_domain/timestamp/query_timestamp_ord_ore_functions.sql +--! @brief Functions for eql_v3.query_timestamp_ord_ore. -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date -); +--! @brief Index extractor for eql_v3.query_timestamp_ord_ore. +--! @param a eql_v3.query_timestamp_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_timestamp_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_date, RIGHTARG = text -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b eql_v3.query_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_date, RIGHTARG = integer -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. +--! @param a eql_v3.query_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b eql_v3.query_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_date, RIGHTARG = text -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. +--! @param a eql_v3.query_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_date, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b eql_v3.query_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_date, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. +--! @param a eql_v3.query_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_date, RIGHTARG = jsonpath -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b eql_v3.query_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_date, RIGHTARG = jsonpath -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. +--! @param a eql_v3.query_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_date, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b eql_v3.query_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_date, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. +--! @param a eql_v3.query_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date, RIGHTARG = text -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b eql_v3.query_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date, RIGHTARG = integer -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. +--! @param a eql_v3.query_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date, RIGHTARG = text[] -); +--! @file encrypted_domain/timestamp/query_timestamp_eq_operators.sql +--! @brief Operators for eql_v3.query_timestamp_eq. -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_date, RIGHTARG = text[] +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = eql_v3.query_timestamp_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_date, RIGHTARG = jsonb +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = eql_v3.query_timestamp_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/date_eq_operators.sql ---! @brief Operators for public.eql_v3_date_eq. +--! @file encrypted_domain/timestamp/timestamp_eq_operators.sql +--! @brief Operators for public.eql_v3_timestamp_eq. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq, + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq, + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/boolean/boolean_operators.sql ---! @brief Operators for public.eql_v3_boolean. - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_boolean, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_boolean, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_boolean, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_boolean, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_boolean, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_boolean, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq ); -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_boolean, RIGHTARG = text[] +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb ); -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonpath +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_boolean, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_boolean, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_boolean, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_boolean, RIGHTARG = integer + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_boolean, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_boolean, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/bigint/query_bigint_ord_ore_operators.sql ---! @brief Operators for eql_v3.query_bigint_ord_ore. +--! @file encrypted_domain/timestamp/query_timestamp_ord_ope_functions.sql +--! @brief Functions for eql_v3.query_timestamp_ord_ope. + +--! @brief Index extractor for eql_v3.query_timestamp_ord_ope. +--! @param a eql_v3.query_timestamp_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_timestamp_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b eql_v3.query_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. +--! @param a eql_v3.query_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b eql_v3.query_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. +--! @param a eql_v3.query_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b eql_v3.query_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. +--! @param a eql_v3.query_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b eql_v3.query_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. +--! @param a eql_v3.query_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b eql_v3.query_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. +--! @param a eql_v3.query_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b eql_v3.query_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. +--! @param a eql_v3.query_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @file encrypted_domain/timestamp/timestamp_ord_ope_aggregates.sql +--! @brief Aggregates for public.eql_v3_timestamp_ord_ope. -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief State function for min on public.eql_v3_timestamp_ord_ope. +--! @param state public.eql_v3_timestamp_ord_ope +--! @param value public.eql_v3_timestamp_ord_ope +--! @return public.eql_v3_timestamp_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord_ope, value public.eql_v3_timestamp_ord_ope) +RETURNS public.eql_v3_timestamp_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +--! @brief min aggregate for public.eql_v3_timestamp_ord_ope. +--! @param input public.eql_v3_timestamp_ord_ope +--! @return public.eql_v3_timestamp_ord_ope +CREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_timestamp_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe ); -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief State function for max on public.eql_v3_timestamp_ord_ope. +--! @param state public.eql_v3_timestamp_ord_ope +--! @param value public.eql_v3_timestamp_ord_ope +--! @return public.eql_v3_timestamp_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord_ope, value public.eql_v3_timestamp_ord_ope) +RETURNS public.eql_v3_timestamp_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +--! @brief max aggregate for public.eql_v3_timestamp_ord_ope. +--! @param input public.eql_v3_timestamp_ord_ope +--! @return public.eql_v3_timestamp_ord_ope +CREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_timestamp_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/bigint/query_bigint_ord_operators.sql ---! @brief Operators for eql_v3.query_bigint_ord. +--! @file encrypted_domain/timestamp/query_timestamp_ord_functions.sql +--! @brief Functions for eql_v3.query_timestamp_ord. -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Index extractor for eql_v3.query_timestamp_ord. +--! @param a eql_v3.query_timestamp_ord +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_timestamp_ord) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b eql_v3.query_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord. +--! @param a eql_v3.query_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b eql_v3.query_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord. +--! @param a eql_v3.query_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b eql_v3.query_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord. +--! @param a eql_v3.query_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b eql_v3.query_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord. +--! @param a eql_v3.query_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b eql_v3.query_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord. +--! @param a eql_v3.query_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b eql_v3.query_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord. +--! @param a eql_v3.query_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/bigint/query_bigint_ord_ope_operators.sql ---! @brief Operators for eql_v3.query_bigint_ord_ope. +--! @file encrypted_domain/timestamp/query_timestamp_ord_ore_operators.sql +--! @brief Operators for eql_v3.query_timestamp_ord_ore. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/bigint/query_bigint_eq_operators.sql ---! @brief Operators for eql_v3.query_bigint_eq. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = eql_v3.query_bigint_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = eql_v3.query_bigint_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_ord_ore_aggregates.sql ---! @brief Aggregates for public.eql_v3_bigint_ord_ore. - ---! @brief State function for min on public.eql_v3_bigint_ord_ore. ---! @param state public.eql_v3_bigint_ord_ore ---! @param value public.eql_v3_bigint_ord_ore ---! @return public.eql_v3_bigint_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord_ore, value public.eql_v3_bigint_ord_ore) -RETURNS public.eql_v3_bigint_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for public.eql_v3_bigint_ord_ore. ---! @param input public.eql_v3_bigint_ord_ore ---! @return public.eql_v3_bigint_ord_ore -CREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_bigint_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on public.eql_v3_bigint_ord_ore. ---! @param state public.eql_v3_bigint_ord_ore ---! @param value public.eql_v3_bigint_ord_ore ---! @return public.eql_v3_bigint_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord_ore, value public.eql_v3_bigint_ord_ore) -RETURNS public.eql_v3_bigint_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for public.eql_v3_bigint_ord_ore. ---! @param input public.eql_v3_bigint_ord_ore ---! @return public.eql_v3_bigint_ord_ore -CREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_bigint_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_ord_ope_aggregates.sql ---! @brief Aggregates for public.eql_v3_bigint_ord_ope. - ---! @brief State function for min on public.eql_v3_bigint_ord_ope. ---! @param state public.eql_v3_bigint_ord_ope ---! @param value public.eql_v3_bigint_ord_ope ---! @return public.eql_v3_bigint_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord_ope, value public.eql_v3_bigint_ord_ope) -RETURNS public.eql_v3_bigint_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for public.eql_v3_bigint_ord_ope. ---! @param input public.eql_v3_bigint_ord_ope ---! @return public.eql_v3_bigint_ord_ope -CREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_bigint_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on public.eql_v3_bigint_ord_ope. ---! @param state public.eql_v3_bigint_ord_ope ---! @param value public.eql_v3_bigint_ord_ope ---! @return public.eql_v3_bigint_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord_ope, value public.eql_v3_bigint_ord_ope) -RETURNS public.eql_v3_bigint_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for public.eql_v3_bigint_ord_ope. ---! @param input public.eql_v3_bigint_ord_ope ---! @return public.eql_v3_bigint_ord_ope -CREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_bigint_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_ord_aggregates.sql ---! @brief Aggregates for public.eql_v3_bigint_ord. - ---! @brief State function for min on public.eql_v3_bigint_ord. ---! @param state public.eql_v3_bigint_ord ---! @param value public.eql_v3_bigint_ord ---! @return public.eql_v3_bigint_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord, value public.eql_v3_bigint_ord) -RETURNS public.eql_v3_bigint_ord +--! @file encrypted_domain/timestamp/timestamp_ord_ore_aggregates.sql +--! @brief Aggregates for public.eql_v3_timestamp_ord_ore. + +--! @brief State function for min on public.eql_v3_timestamp_ord_ore. +--! @param state public.eql_v3_timestamp_ord_ore +--! @param value public.eql_v3_timestamp_ord_ore +--! @return public.eql_v3_timestamp_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord_ore, value public.eql_v3_timestamp_ord_ore) +RETURNS public.eql_v3_timestamp_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -42040,22 +45175,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_bigint_ord. ---! @param input public.eql_v3_bigint_ord ---! @return public.eql_v3_bigint_ord -CREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord) ( +--! @brief min aggregate for public.eql_v3_timestamp_ord_ore. +--! @param input public.eql_v3_timestamp_ord_ore +--! @return public.eql_v3_timestamp_ord_ore +CREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord_ore) ( sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_bigint_ord, + stype = public.eql_v3_timestamp_ord_ore, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_bigint_ord. ---! @param state public.eql_v3_bigint_ord ---! @param value public.eql_v3_bigint_ord ---! @return public.eql_v3_bigint_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord, value public.eql_v3_bigint_ord) -RETURNS public.eql_v3_bigint_ord +--! @brief State function for max on public.eql_v3_timestamp_ord_ore. +--! @param state public.eql_v3_timestamp_ord_ore +--! @param value public.eql_v3_timestamp_ord_ore +--! @return public.eql_v3_timestamp_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord_ore, value public.eql_v3_timestamp_ord_ore) +RETURNS public.eql_v3_timestamp_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -42067,872 +45202,523 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_bigint_ord. ---! @param input public.eql_v3_bigint_ord ---! @return public.eql_v3_bigint_ord -CREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord) ( +--! @brief max aggregate for public.eql_v3_timestamp_ord_ore. +--! @param input public.eql_v3_timestamp_ord_ore +--! @return public.eql_v3_timestamp_ord_ore +CREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord_ore) ( sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_bigint_ord, + stype = public.eql_v3_timestamp_ord_ore, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/bigint/bigint_operators.sql ---! @brief Operators for public.eql_v3_bigint. +--! @file encrypted_domain/timestamp/timestamp_operators.sql +--! @brief Operators for public.eql_v3_timestamp. CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint + LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint + LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint + LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint + LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint + LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint + LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint + LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint + LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_bigint, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_bigint, RIGHTARG = integer + LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_bigint, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_bigint, RIGHTARG = integer + LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_bigint, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_bigint, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_bigint, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_bigint, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_bigint, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_bigint, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_eq_operators.sql ---! @brief Operators for public.eql_v3_bigint_eq. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp ); -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[] +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb ); -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonpath +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq + LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp ); +-- AUTOMATICALLY GENERATED FILE. ---! @brief EQL lint: detect non-inlinable operator implementation functions ---! ---! Returns one row per violation found in the installed `eql_v3` surface. The ---! Postgres planner can only inline a function during index matching when: ---! ---! * `LANGUAGE sql` (plpgsql / C / etc. cannot be inlined) ---! * `IMMUTABLE` or `STABLE` volatility (VOLATILE cannot be inlined into ---! index expressions) ---! * No `SET` clauses (e.g. `SET search_path = ...`) ---! * Not `SECURITY DEFINER` ---! * Single-statement SELECT body ---! ---! @note The single-statement SELECT body condition is **not yet checked** by ---! this lint. A `LANGUAGE sql` function with a multi-statement body, a CTE, ---! or any pre-SELECT statement will pass all four implemented checks while ---! remaining non-inlinable. Implementing the check requires walking `prosrc` ---! (or `pg_get_functiondef`); tracked as a follow-up. ---! ---! Operators on `eql_v3` types (the jsonb-backed encrypted-domain families and ---! the SEM index-term type `eql_v3_internal.ore_block_256`) whose ---! implementation functions fail any of these rules silently fall back to seq ---! scan when the documented functional indexes (`eql_v3.eq_term(col)`, ---! `eql_v3.ord_term(col)`) are in place. This lint surfaces every such case. ---! ---! Severity: ---! `error` — fixable, blocks index matching, ship-blocking. ---! `warning` — likely-fixable, may not block matching but signals intent. ---! `info` — observational; useful for review, not a defect on its own. ---! ---! Categories: ---! `inlinability_language` — implementation function isn't `LANGUAGE sql`. ---! `inlinability_volatility` — implementation function is VOLATILE. ---! `inlinability_set_clause` — implementation function has a `SET` clause. ---! `inlinability_secdef` — implementation function is `SECURITY DEFINER`. ---! `inlinability_transitive` — implementation function is itself inlinable ---! but its body invokes a non-inlinable function ---! (depth 1; the planner can't peek through ---! that boundary). ---! `blocker_language` — encrypted-domain blocker is not LANGUAGE ---! plpgsql. The planner can inline / elide a ---! LANGUAGE sql body when the result is ---! provably unused, silently bypassing the ---! RAISE that the blocker exists to perform. ---! `blocker_strict` — encrypted-domain blocker is STRICT. ---! PostgreSQL skips the body and returns NULL ---! on NULL arguments, silently bypassing the ---! RAISE. ---! `domain_over_domain` — an `eql_v3` encrypted domain is derived from ---! another encrypted domain rather than jsonb. ---! Operators resolve against the ultimate base ---! type, so the derived domain does not ---! inherit the base domain's blocker surface. ---! `domain_opclass` — an operator class is declared FOR TYPE on an ---! `eql_v3` encrypted domain. Opclasses on ---! domains bypass operator resolution; use a ---! functional index on the extractor instead. ---! `schema_placement` — a naked composite or enum TYPE lives in the ---! public `eql_v3` schema. Internal index-term ---! types (e.g. `ore_block_256_term`) belong in ---! `eql_v3_internal`; a composite/enum in ---! `eql_v3` clutters the Supabase Table Builder ---! type picker, which the schema split exists to ---! prevent. Move it to `eql_v3_internal`. ---! ---! @example ---! ``` ---! SELECT severity, category, object_name, message ---! FROM eql_v3.lints() ---! WHERE severity = 'error' ---! ORDER BY category, object_name; ---! ``` ---! ---! @return SETOF record (severity text, category text, object_name text, message text) -CREATE OR REPLACE FUNCTION eql_v3.lints() -RETURNS TABLE ( - severity text, - category text, - object_name text, - message text -) -LANGUAGE sql STABLE -AS $$ - WITH - -- User-column encrypted domains now live in public so application tables - -- survive EQL uninstall. Keep this separate from owned_schemas(): public is - -- not installer-owned, but its EQL jsonb-backed domains are still the domain - -- types whose blockers/operator surfaces the lint must understand. - encrypted_domain_types AS ( - SELECT - dt.oid AS typid - FROM pg_catalog.pg_type dt - JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace - JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype - JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace - WHERE dt.typtype = 'd' - AND bt.typname = 'jsonb' - AND bn.nspname = 'pg_catalog' - AND ( - dn.nspname = 'public' - OR dn.nspname = ANY(eql_v3_internal.owned_schemas()) - ) - ), +--! @file encrypted_domain/timestamp/query_timestamp_ord_operators.sql +--! @brief Operators for eql_v3.query_timestamp_ord. - -- All operators where at least one operand is an EQL-owned type or a public - -- encrypted domain. Limits the scope of the lint to the operator surface - -- customers actually hit via SQL (`col = val`, `col @> '...'` and friends). - eql_operators AS ( - SELECT - op.oid AS oprid, - op.oprname AS opname, - op.oprcode AS implfunc, - op.oprleft::regtype AS lhs, - op.oprright::regtype AS rhs, - op.oprcode::regprocedure AS impl_signature - FROM pg_operator op - WHERE EXISTS ( - SELECT 1 FROM pg_type t - WHERE t.oid IN (op.oprleft, op.oprright) - AND ( - t.typnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY(eql_v3_internal.owned_schemas())) - OR t.oid IN (SELECT typid FROM encrypted_domain_types) - ) - ) - ), +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - -- Cross-join with each operator's implementation function metadata. - -- One row per operator; columns describe the inlinability of the impl. - op_impl AS ( - SELECT - eo.opname, - eo.lhs, - eo.rhs, - eo.implfunc AS impl_oid, - eo.impl_signature::text AS impl_signature, - lang_l.lanname AS lang, - p.provolatile AS volatility, - p.proconfig AS config, - p.prosecdef AS secdef, - p.prosrc AS body - FROM eql_operators eo - JOIN pg_proc p ON p.oid = eo.implfunc - JOIN pg_language lang_l ON lang_l.oid = p.prolang - ), +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - -- Encrypted-domain blockers: functions in `eql_v3` whose body contains - -- a blocker marker emitted by the codegen (any of the - -- `encrypted_domain_unsupported_*` helper calls — `_bool` for boolean - -- blockers, `_jsonb` for the native-jsonb-operator blockers; plus the - -- literal `is not supported for` for older path-operator blockers) AND - -- that take at least one encrypted domain over jsonb argument. The argument - -- filter excludes the shared `encrypted_domain_unsupported_*(text, text)` - -- helpers themselves, which contain the marker in their body but are not - -- blockers (they take text arguments, not a domain). - encrypted_domain_blockers AS ( - SELECT - p.oid AS oid, - p.oid::regprocedure::text AS signature, - lang_l.lanname AS lang, - p.proisstrict AS isstrict - FROM pg_catalog.pg_proc p - JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace - JOIN pg_catalog.pg_language lang_l ON lang_l.oid = p.prolang - WHERE n.nspname = ANY(eql_v3_internal.owned_schemas()) - AND (p.prosrc LIKE '%encrypted_domain_unsupported%' - OR p.prosrc LIKE '%is not supported for%') - AND EXISTS ( - SELECT 1 - FROM pg_catalog.unnest(p.proargtypes::oid[]) AS arg(typ) - JOIN encrypted_domain_types edt ON edt.typid = arg.typ - ) - ) +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); - -- ┌─────────────────────────────────────────────────────────────────┐ - -- │ Direct inlinability checks: each row examines one operator's │ - -- │ implementation function and emits a violation if any rule is │ - -- │ broken. Multiple violations on the same function become │ - -- │ multiple rows (developers see every reason it doesn't inline). │ - -- └─────────────────────────────────────────────────────────────────┘ +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); - SELECT - 'error' AS severity, - 'inlinability_language' AS category, - format('operator %s(%s, %s) -> %s', - opname, lhs, rhs, impl_signature) AS object_name, - format( - '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.', - lang, opname) AS message - FROM op_impl - WHERE lang <> 'sql' - AND NOT EXISTS ( - SELECT 1 FROM encrypted_domain_blockers b - WHERE b.oid = op_impl.impl_oid - ) +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); - UNION ALL +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); - SELECT - 'error', - 'inlinability_volatility', - format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature), - format( - '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).', - opname) - FROM op_impl - WHERE volatility = 'v' - AND NOT EXISTS ( - SELECT 1 FROM encrypted_domain_blockers b - WHERE b.oid = op_impl.impl_oid - ) +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); - UNION ALL +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); - SELECT - 'error', - 'inlinability_set_clause', - format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature), - format( - '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.') - FROM op_impl - WHERE config IS NOT NULL - AND NOT EXISTS ( - SELECT 1 FROM encrypted_domain_blockers b - WHERE b.oid = op_impl.impl_oid - ) +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); - UNION ALL +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); - SELECT - 'error', - 'inlinability_secdef', - format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature), - 'Operator implementation function is `SECURITY DEFINER`. Such functions cannot be inlined; remove `SECURITY DEFINER` or use a non-inlinable wrapper layer.' - FROM op_impl - WHERE secdef - AND NOT EXISTS ( - SELECT 1 FROM encrypted_domain_blockers b - WHERE b.oid = op_impl.impl_oid - ) +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); - -- ┌─────────────────────────────────────────────────────────────────┐ - -- │ Transitive inlinability: an operator implementation function │ - -- │ that's itself inlinable can still fail to inline if its body │ - -- │ calls a non-inlinable function. Walk one level via pg_depend. │ - -- │ │ - -- │ Postgres records function-to-function dependencies in │ - -- │ pg_depend with deptype 'n' (normal) when one function references│ - -- │ another in its body — but only at CREATE time and only for │ - -- │ direct calls. This is good enough for v1; deeper transitive │ - -- │ analysis is a follow-up. │ - -- └─────────────────────────────────────────────────────────────────┘ +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. - UNION ALL +--! @file encrypted_domain/timestamp/query_timestamp_ord_ope_operators.sql +--! @brief Operators for eql_v3.query_timestamp_ord_ope. - SELECT - 'error', - 'inlinability_transitive', - format('operator %s(%s, %s) -> %s', oi.opname, oi.lhs, oi.rhs, - oi.impl_signature), - format( - '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.', - called.proname, - called_lang.lanname, - CASE called.provolatile - WHEN 'i' THEN 'IMMUTABLE' - WHEN 's' THEN 'STABLE' - WHEN 'v' THEN 'VOLATILE' - END, - CASE WHEN called.proconfig IS NOT NULL - THEN ', has SET clause' - ELSE '' END) - FROM op_impl oi - -- Only worth the transitive check if the outer function is otherwise - -- inlinable — otherwise the direct lints above already report it. - JOIN pg_proc outer_p ON outer_p.oid = oi.impl_signature::regprocedure - JOIN pg_depend d - ON d.classid = 'pg_proc'::regclass - AND d.objid = outer_p.oid - AND d.refclassid = 'pg_proc'::regclass - AND d.deptype = 'n' - JOIN pg_proc called ON called.oid = d.refobjid - JOIN pg_language called_lang ON called_lang.oid = called.prolang - WHERE oi.lang = 'sql' - AND oi.volatility IN ('i', 's') - AND oi.config IS NULL - AND NOT oi.secdef - AND called.oid <> outer_p.oid - AND ( - called_lang.lanname <> 'sql' - OR called.provolatile = 'v' - OR called.proconfig IS NOT NULL - OR called.prosecdef - ) +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - -- ┌─────────────────────────────────────────────────────────────────┐ - -- │ Encrypted-domain footguns: blockers exist to RAISE, so they │ - -- │ have inverted inlinability requirements vs operator impls. │ - -- │ A LANGUAGE sql blocker can be elided by the planner; a STRICT │ - -- │ blocker returns NULL on NULL args. Both silently re-enable │ - -- │ operators the storage variant is supposed to block. │ - -- └─────────────────────────────────────────────────────────────────┘ +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - UNION ALL +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); - SELECT - 'error', - 'blocker_language', - format('function %s', signature), - format( - '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.', - lang) - FROM encrypted_domain_blockers - WHERE lang <> 'plpgsql' +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); - UNION ALL +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); - SELECT - 'error', - 'blocker_strict', - format('function %s', signature), - 'Encrypted-domain blocker is `STRICT`. PostgreSQL skips the body and returns NULL on a NULL argument, silently bypassing the RAISE. Remove `STRICT`.' - FROM encrypted_domain_blockers - WHERE isstrict +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); - -- ┌─────────────────────────────────────────────────────────────────┐ - -- │ Domain identity: an encrypted-domain must be defined directly │ - -- │ over jsonb. Operators resolve against the ultimate base type, │ - -- │ so domain-over-domain inherits jsonb's operator surface and not │ - -- │ the base domain's blockers. │ - -- └─────────────────────────────────────────────────────────────────┘ +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); - UNION ALL +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); - SELECT - 'error', - 'domain_over_domain', - format('domain %I.%I', dn.nspname, dt.typname), - format( - '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.', - dn.nspname, dt.typname, bn.nspname, bt.typname) - FROM pg_catalog.pg_type dt - JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace - JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype - JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace - WHERE dt.typtype = 'd' - AND dn.nspname = ANY(eql_v3_internal.owned_schemas()) - AND bt.typtype = 'd' - AND bt.oid IN (SELECT typid FROM encrypted_domain_types) +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); - -- ┌─────────────────────────────────────────────────────────────────┐ - -- │ Domain opclass: an operator class declared FOR TYPE on an │ - -- │ encrypted-domain bypasses operator resolution at index time. │ - -- │ Use a functional index on the extractor instead. │ - -- └─────────────────────────────────────────────────────────────────┘ +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); - UNION ALL +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); - SELECT - 'error', - 'domain_opclass', - format('opclass %I.%I FOR TYPE %s.%s', cn.nspname, oc.opcname, tn.nspname, t.typname), - format( - '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.', - cn.nspname, oc.opcname, tn.nspname, t.typname, tn.nspname, tn.nspname) - FROM pg_catalog.pg_opclass oc - JOIN pg_catalog.pg_type t ON t.oid = oc.opcintype - JOIN pg_catalog.pg_namespace tn ON tn.oid = t.typnamespace - JOIN pg_catalog.pg_namespace cn ON cn.oid = oc.opcnamespace - WHERE t.oid IN (SELECT typid FROM encrypted_domain_types) +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); - -- ┌─────────────────────────────────────────────────────────────────┐ - -- │ Schema placement: the public `eql_v3` schema must hold only the │ - -- │ jsonb-backed encrypted-domain types. A naked composite/enum type │ - -- │ there is an internal index-term type in the wrong schema — it │ - -- │ clutters the Supabase type picker the split exists to keep clean. │ - -- └─────────────────────────────────────────────────────────────────┘ +--! @file v3/json/aggregates.sql +--! @brief min / max aggregates over public.eql_v3_json_entry. +--! +--! SteVec document entries extracted at a selector (`doc -> 'sel'`) order by +--! their CLLW OPE (`op`) term, so the extremum is picked by comparing +--! `eql_v3.ord_term(entry)` rather than the scalar Block-ORE `ord_term` the +--! generated scalar ord aggregates use. The ope_cllw bytea domain orders under +--! native byte comparison, so `<` / `>` on the extracted terms needs no custom +--! comparator. Same STRICT + PARALLEL SAFE shape as the generated scalar +--! `min`/`max` so partial/parallel aggregation is available on large GROUP BY +--! workloads. +--! +--! Per the encrypted-domain footgun rules the state functions are +--! `LANGUAGE plpgsql` with the pinned `search_path` — a `LANGUAGE sql` body would +--! be inlinable and the planner could elide it. +--! +--! @note **Only `op`-carrying entries are orderable.** `eql_v3.ord_term(entry)` +--! returns NULL when an entry has no `op` (CLLW OPE) term — the same entries a +--! `eql_v3.ord_term` btree NULL-filters from range scans. The state functions +--! therefore IGNORE `op`-less entries (they never become or survive as the +--! extremum), so `min`/`max` is well-defined over a mix of `op`-carrying and +--! `op`-less entries and is not corrupted by an `op`-less seed. A naive +--! `ord_term(value) < ord_term(state)` would be NULL whenever either side +--! lacks `op`, pinning a wrong (`op`-less) extremum when the first aggregated +--! row is `op`-less. An all-`op`-less input has no orderable extremum and +--! returns the (arbitrary) STRICT seed. - UNION ALL +--! @brief State function for min on public.eql_v3_json_entry. +--! +--! Keeps whichever orderable entry has the lesser CLLW OPE term. STRICT, so SQL +--! NULL entries are skipped by the aggregate machinery; `op`-less (non-orderable) +--! entries are skipped explicitly (see the @note on this file). +--! +--! @param state public.eql_v3_json_entry Running extremum. +--! @param value public.eql_v3_json_entry Candidate entry. +--! @return public.eql_v3_json_entry The lesser orderable entry by `ord_term`. +CREATE FUNCTION eql_v3_internal.jsonb_entry_min_sfunc( + state public.eql_v3_json_entry, + value public.eql_v3_json_entry +) +RETURNS public.eql_v3_json_entry +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +DECLARE + value_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(value); + state_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(state); +BEGIN + -- A non-orderable (op-less) candidate never replaces the running extremum. + IF value_ope IS NULL THEN + RETURN state; + END IF; + -- Adopt the candidate when the running extremum is itself non-orderable + -- (e.g. an op-less STRICT seed) or strictly greater. + IF state_ope IS NULL OR value_ope < state_ope THEN + RETURN value; + END IF; + RETURN state; +END; +$$; - SELECT - 'error', - 'schema_placement', - format('type %I.%I', n.nspname, t.typname), - format( - '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.nspname, t.typname, - CASE t.typtype WHEN 'c' THEN 'composite type' WHEN 'e' THEN 'enum type' ELSE 'type' END) - FROM pg_catalog.pg_type t - JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace - WHERE n.nspname = 'eql_v3' - AND t.typtype IN ('c', 'e') +--! @brief min aggregate over public.eql_v3_json_entry. +--! @param input public.eql_v3_json_entry +--! @return public.eql_v3_json_entry The entry with the smallest CLLW OPE term. +CREATE AGGREGATE eql_v3.min(public.eql_v3_json_entry) ( + sfunc = eql_v3_internal.jsonb_entry_min_sfunc, + stype = public.eql_v3_json_entry, + combinefunc = eql_v3_internal.jsonb_entry_min_sfunc, + parallel = safe +); - ORDER BY 1, 2, 3; +--! @brief State function for max on public.eql_v3_json_entry. +--! +--! Keeps whichever orderable entry has the greater CLLW OPE term. `op`-less +--! entries are skipped, mirroring `jsonb_entry_min_sfunc` (see the file @note). +--! +--! @param state public.eql_v3_json_entry Running extremum. +--! @param value public.eql_v3_json_entry Candidate entry. +--! @return public.eql_v3_json_entry The greater orderable entry by `ord_term`. +CREATE FUNCTION eql_v3_internal.jsonb_entry_max_sfunc( + state public.eql_v3_json_entry, + value public.eql_v3_json_entry +) +RETURNS public.eql_v3_json_entry +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +DECLARE + value_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(value); + state_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(state); +BEGIN + -- A non-orderable (op-less) candidate never replaces the running extremum. + IF value_ope IS NULL THEN + RETURN state; + END IF; + -- Adopt the candidate when the running extremum is itself non-orderable + -- (e.g. an op-less STRICT seed) or strictly lesser. + IF state_ope IS NULL OR value_ope > state_ope THEN + RETURN value; + END IF; + RETURN state; +END; $$; -COMMENT ON FUNCTION eql_v3.lints() IS - 'EQL lint: returns one row per non-inlinable operator implementation. ' - 'Run `SELECT * FROM eql_v3.lints() WHERE severity = ''error''` for a ' - 'CI-gateable check that all operator implementations on eql_v3 types are ' - 'eligible for planner inlining.'; +--! @brief max aggregate over public.eql_v3_json_entry. +--! @param input public.eql_v3_json_entry +--! @return public.eql_v3_json_entry The entry with the largest CLLW OPE term. +CREATE AGGREGATE eql_v3.max(public.eql_v3_json_entry) ( + sfunc = eql_v3_internal.jsonb_entry_max_sfunc, + stype = public.eql_v3_json_entry, + combinefunc = eql_v3_internal.jsonb_entry_max_sfunc, + parallel = safe +); ---! @file v3/jsonb/operators.sql ---! @brief Operators on public.eql_v3_json and public.eql_v3_jsonb_entry. +--! @file v3/json/operators.sql +--! @brief Operators on public.eql_v3_json_search and public.eql_v3_json_entry. ------------------------------------------------------------------------------ -- -> field accessor (returns jsonb_entry) @@ -42949,17 +45735,17 @@ COMMENT ON FUNCTION eql_v3.lints() IS --! parameter (`$1`, the Proxy interface) or an explicit cast (`col -> 'sel'::%text`). --! A bare untyped literal (`col -> 'sel'`) resolves to the NATIVE `jsonb -> %text` --! operator and silently returns native jsonb semantics (a root-key lookup, ---! typically NULL), NOT this operator: PostgreSQL reduces the `public.eql_v3_json` +--! typically NULL), NOT this operator: PostgreSQL reduces the `public.eql_v3_json_search` --! domain to its base type `jsonb` when resolving an unknown-typed RHS, and the --! native base-type operator wins the exact-match tiebreak. This is intrinsic to --! the domain type-kind and applies to the native-jsonb blockers too. See --! the "Typed operands" caveat in docs/reference/json-support.md. --! ---! @param e public.eql_v3_json Root encrypted payload. +--! @param e public.eql_v3_json_search Root encrypted payload. --! @param selector text Selector hash. ---! @return public.eql_v3_jsonb_entry Matching entry merged with root meta, or NULL. -CREATE FUNCTION eql_v3."->"(e public.eql_v3_json, selector text) - RETURNS public.eql_v3_jsonb_entry +--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL. +CREATE FUNCTION eql_v3."->"(e public.eql_v3_json_search, selector text) + RETURNS public.eql_v3_json_entry LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT ( @@ -42969,40 +45755,40 @@ AS $$ '$.sv[*] ? (@.s == $sel)'::jsonpath, jsonb_build_object('sel', selector) ) - )::public.eql_v3_jsonb_entry + )::public.eql_v3_json_entry $$; CREATE OPERATOR ->( FUNCTION=eql_v3."->", - LEFTARG=public.eql_v3_json, + LEFTARG=public.eql_v3_json_search, RIGHTARG=text ); --! @brief -> operator with integer array index (0-based, JSONB convention). ---! @param e public.eql_v3_json Encrypted sv-array payload. +--! @param e public.eql_v3_json_search Encrypted sv-array payload. --! @param selector integer Array index. ---! @return public.eql_v3_jsonb_entry Matching entry merged with root meta, or NULL. -CREATE FUNCTION eql_v3."->"(e public.eql_v3_json, selector integer) - RETURNS public.eql_v3_jsonb_entry +--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL. +CREATE FUNCTION eql_v3."->"(e public.eql_v3_json_search, selector integer) + RETURNS public.eql_v3_json_entry LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT CASE WHEN eql_v3_internal.is_ste_vec_array(e) THEN -- NOTE: `e::jsonb` makes the native-jsonb traversal explicit. `'sv'` is an - -- unknown-typed literal, so `e -> 'sv'` already flattens `public.eql_v3_json` to + -- unknown-typed literal, so `e -> 'sv'` already flattens `public.eql_v3_json_search` to -- its base type and binds native `jsonb -> text` (see the @warning above) — - -- the custom `->(public.eql_v3_json, text)` operator does NOT capture a bare + -- the custom `->(public.eql_v3_json_search, text)` operator does NOT capture a bare -- untyped literal. The cast documents that intent and guards the `-> selector` - -- (integer) hop from ever resolving to the v3 `->(public.eql_v3_json, integer)` + -- (integer) hop from ever resolving to the v3 `->(public.eql_v3_json_search, integer)` -- operator instead of native array access. - (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::public.eql_v3_jsonb_entry + (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::public.eql_v3_json_entry ELSE NULL END $$; CREATE OPERATOR ->( FUNCTION=eql_v3."->", - LEFTARG=public.eql_v3_json, + LEFTARG=public.eql_v3_json_search, RIGHTARG=integer ); @@ -43016,10 +45802,10 @@ CREATE OPERATOR ->( --! Intentional v2 parity: this serializes the entire matched jsonb_entry --! object as JSON text. It does not decrypt or return scalar plaintext like --! native `jsonb ->>`. ---! @param e public.eql_v3_json Encrypted payload. +--! @param e public.eql_v3_json_search Encrypted payload. --! @param selector text Field selector hash. --! @return text The matching entry as text. -CREATE FUNCTION eql_v3."->>"(e public.eql_v3_json, selector text) +CREATE FUNCTION eql_v3."->>"(e public.eql_v3_json_search, selector text) RETURNS text LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -43028,16 +45814,16 @@ $$; CREATE OPERATOR ->> ( FUNCTION=eql_v3."->>", - LEFTARG=public.eql_v3_json, + LEFTARG=public.eql_v3_json_search, RIGHTARG=text ); --! @brief ->> operator with integer array index. Inlinable alias of --! ->(json, integer) coerced to text. ---! @param e public.eql_v3_json Encrypted sv-array payload. +--! @param e public.eql_v3_json_search Encrypted sv-array payload. --! @param selector integer Array index. --! @return text The matching entry as text. -CREATE FUNCTION eql_v3."->>"(e public.eql_v3_json, selector integer) +CREATE FUNCTION eql_v3."->>"(e public.eql_v3_json_search, selector integer) RETURNS text LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -43046,7 +45832,7 @@ $$; CREATE OPERATOR ->> ( FUNCTION=eql_v3."->>", - LEFTARG=public.eql_v3_json, + LEFTARG=public.eql_v3_json_search, RIGHTARG=integer ); @@ -43055,11 +45841,11 @@ CREATE OPERATOR ->> ( ------------------------------------------------------------------------------ --! @brief @> contains operator (document, document). ---! @param a public.eql_v3_json Container. ---! @param b public.eql_v3_json Contained value. +--! @param a public.eql_v3_json_search Container. +--! @param b public.eql_v3_json_search Contained value. --! @return boolean True if a contains b. --! @see eql_v3.ste_vec_contains -CREATE FUNCTION eql_v3."@>"(a public.eql_v3_json, b public.eql_v3_json) +CREATE FUNCTION eql_v3."@>"(a public.eql_v3_json_search, b public.eql_v3_json_search) RETURNS boolean LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -43068,19 +45854,19 @@ $$; CREATE OPERATOR @>( FUNCTION=eql_v3."@>", - LEFTARG=public.eql_v3_json, - RIGHTARG=public.eql_v3_json + LEFTARG=public.eql_v3_json_search, + RIGHTARG=public.eql_v3_json_search ); ---! @brief @> contains operator with an query_jsonb needle. +--! @brief @> contains operator with an query_json needle. --! --! Inlines to native `jsonb @>` over `eql_v3.to_ste_vec_query(a)::jsonb`, so a --! functional GIN index on the same expression engages. --! ---! @param a public.eql_v3_json Container. ---! @param b eql_v3.query_jsonb Query payload. +--! @param a public.eql_v3_json_search Container. +--! @param b eql_v3.query_json Query payload. --! @return boolean True if a contains b. -CREATE FUNCTION eql_v3."@>"(a public.eql_v3_json, b eql_v3.query_jsonb) +CREATE FUNCTION eql_v3."@>"(a public.eql_v3_json_search, b eql_v3.query_json) RETURNS boolean LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -43089,8 +45875,8 @@ $$; CREATE OPERATOR @>( FUNCTION=eql_v3."@>", - LEFTARG=public.eql_v3_json, - RIGHTARG=eql_v3.query_jsonb + LEFTARG=public.eql_v3_json_search, + RIGHTARG=eql_v3.query_json ); --! @brief @> contains operator with a single jsonb_entry needle. @@ -43098,10 +45884,10 @@ CREATE OPERATOR @>( --! Wraps the entry into a single-element sv array (stripping `c`) and reduces --! to the same `to_ste_vec_query(a)::jsonb @> needle::jsonb` form. --! ---! @param a public.eql_v3_json Container. ---! @param b public.eql_v3_jsonb_entry Single entry. +--! @param a public.eql_v3_json_search Container. +--! @param b public.eql_v3_json_entry Single entry. --! @return boolean True if a contains an sv entry matching b. -CREATE FUNCTION eql_v3."@>"(a public.eql_v3_json, b public.eql_v3_jsonb_entry) +CREATE FUNCTION eql_v3."@>"(a public.eql_v3_json_search, b public.eql_v3_json_entry) RETURNS boolean LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -43122,8 +45908,8 @@ $$; CREATE OPERATOR @>( FUNCTION=eql_v3."@>", - LEFTARG=public.eql_v3_json, - RIGHTARG=public.eql_v3_jsonb_entry + LEFTARG=public.eql_v3_json_search, + RIGHTARG=public.eql_v3_json_entry ); ------------------------------------------------------------------------------ @@ -43131,10 +45917,10 @@ CREATE OPERATOR @>( ------------------------------------------------------------------------------ --! @brief <@ contained-by operator (document, document). ---! @param a public.eql_v3_json Contained value. ---! @param b public.eql_v3_json Container. +--! @param a public.eql_v3_json_search Contained value. +--! @param b public.eql_v3_json_search Container. --! @return boolean True if a is contained by b. -CREATE FUNCTION eql_v3."<@"(a public.eql_v3_json, b public.eql_v3_json) +CREATE FUNCTION eql_v3."<@"(a public.eql_v3_json_search, b public.eql_v3_json_search) RETURNS boolean LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -43143,15 +45929,15 @@ $$; CREATE OPERATOR <@( FUNCTION=eql_v3."<@", - LEFTARG=public.eql_v3_json, - RIGHTARG=public.eql_v3_json + LEFTARG=public.eql_v3_json_search, + RIGHTARG=public.eql_v3_json_search ); ---! @brief <@ contained-by operator with an query_jsonb LHS. ---! @param a eql_v3.query_jsonb Query payload. ---! @param b public.eql_v3_json Container. +--! @brief <@ contained-by operator with an query_json LHS. +--! @param a eql_v3.query_json Query payload. +--! @param b public.eql_v3_json_search Container. --! @return boolean True if b contains a. -CREATE FUNCTION eql_v3."<@"(a eql_v3.query_jsonb, b public.eql_v3_json) +CREATE FUNCTION eql_v3."<@"(a eql_v3.query_json, b public.eql_v3_json_search) RETURNS boolean LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -43160,15 +45946,15 @@ $$; CREATE OPERATOR <@( FUNCTION=eql_v3."<@", - LEFTARG=eql_v3.query_jsonb, - RIGHTARG=public.eql_v3_json + LEFTARG=eql_v3.query_json, + RIGHTARG=public.eql_v3_json_search ); --! @brief <@ contained-by operator with a jsonb_entry LHS. ---! @param a public.eql_v3_jsonb_entry Single entry. ---! @param b public.eql_v3_json Container. +--! @param a public.eql_v3_json_entry Single entry. +--! @param b public.eql_v3_json_search Container. --! @return boolean True if b contains a. -CREATE FUNCTION eql_v3."<@"(a public.eql_v3_jsonb_entry, b public.eql_v3_json) +CREATE FUNCTION eql_v3."<@"(a public.eql_v3_json_entry, b public.eql_v3_json_search) RETURNS boolean LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -43177,8 +45963,8 @@ $$; CREATE OPERATOR <@( FUNCTION=eql_v3."<@", - LEFTARG=public.eql_v3_jsonb_entry, - RIGHTARG=public.eql_v3_json + LEFTARG=public.eql_v3_json_entry, + RIGHTARG=public.eql_v3_json_search ); ------------------------------------------------------------------------------ @@ -43186,10 +45972,10 @@ CREATE OPERATOR <@( ------------------------------------------------------------------------------ --! @brief Equality on jsonb_entry via eq_term (hm-or-op byte equality). ---! @param a public.eql_v3_jsonb_entry Left operand ---! @param b public.eql_v3_jsonb_entry Right operand +--! @param a public.eql_v3_json_entry Left operand +--! @param b public.eql_v3_json_entry Right operand --! @return boolean True if the entries are equal -CREATE FUNCTION eql_v3.eq(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_json_entry, b public.eql_v3_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -43198,8 +45984,8 @@ $$; CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_jsonb_entry, - RIGHTARG = public.eql_v3_jsonb_entry, + LEFTARG = public.eql_v3_json_entry, + RIGHTARG = public.eql_v3_json_entry, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, @@ -43207,10 +45993,10 @@ CREATE OPERATOR = ( ); --! @brief Inequality on jsonb_entry via eq_term. ---! @param a public.eql_v3_jsonb_entry Left operand ---! @param b public.eql_v3_jsonb_entry Right operand +--! @param a public.eql_v3_json_entry Left operand +--! @param b public.eql_v3_json_entry Right operand --! @return boolean True if the entries are not equal -CREATE FUNCTION eql_v3.neq(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_json_entry, b public.eql_v3_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -43219,8 +46005,8 @@ $$; CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_jsonb_entry, - RIGHTARG = public.eql_v3_jsonb_entry, + LEFTARG = public.eql_v3_json_entry, + RIGHTARG = public.eql_v3_json_entry, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, @@ -43228,10 +46014,10 @@ CREATE OPERATOR <> ( ); --! @brief Less-than on jsonb_entry via the CLLW OPE term (native bytea order). ---! @param a public.eql_v3_jsonb_entry Left operand ---! @param b public.eql_v3_jsonb_entry Right operand +--! @param a public.eql_v3_json_entry Left operand +--! @param b public.eql_v3_json_entry Right operand --! @return boolean True if a is less than b -CREATE FUNCTION eql_v3.lt(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b public.eql_v3_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -43240,8 +46026,8 @@ $$; CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_jsonb_entry, - RIGHTARG = public.eql_v3_jsonb_entry, + LEFTARG = public.eql_v3_json_entry, + RIGHTARG = public.eql_v3_json_entry, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, @@ -43249,10 +46035,10 @@ CREATE OPERATOR < ( ); --! @brief Less-than-or-equal on jsonb_entry via the CLLW OPE term. ---! @param a public.eql_v3_jsonb_entry Left operand ---! @param b public.eql_v3_jsonb_entry Right operand +--! @param a public.eql_v3_json_entry Left operand +--! @param b public.eql_v3_json_entry Right operand --! @return boolean True if a is less than or equal to b -CREATE FUNCTION eql_v3.lte(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b public.eql_v3_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -43261,8 +46047,8 @@ $$; CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_jsonb_entry, - RIGHTARG = public.eql_v3_jsonb_entry, + LEFTARG = public.eql_v3_json_entry, + RIGHTARG = public.eql_v3_json_entry, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, @@ -43270,10 +46056,10 @@ CREATE OPERATOR <= ( ); --! @brief Greater-than on jsonb_entry via the CLLW OPE term. ---! @param a public.eql_v3_jsonb_entry Left operand ---! @param b public.eql_v3_jsonb_entry Right operand +--! @param a public.eql_v3_json_entry Left operand +--! @param b public.eql_v3_json_entry Right operand --! @return boolean True if a is greater than b -CREATE FUNCTION eql_v3.gt(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b public.eql_v3_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -43282,8 +46068,8 @@ $$; CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_jsonb_entry, - RIGHTARG = public.eql_v3_jsonb_entry, + LEFTARG = public.eql_v3_json_entry, + RIGHTARG = public.eql_v3_json_entry, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, @@ -43291,10 +46077,10 @@ CREATE OPERATOR > ( ); --! @brief Greater-than-or-equal on jsonb_entry via the CLLW OPE term. ---! @param a public.eql_v3_jsonb_entry Left operand ---! @param b public.eql_v3_jsonb_entry Right operand +--! @param a public.eql_v3_json_entry Left operand +--! @param b public.eql_v3_json_entry Right operand --! @return boolean True if a is greater than or equal to b -CREATE FUNCTION eql_v3.gte(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b public.eql_v3_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -43303,19 +46089,19 @@ $$; CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_jsonb_entry, - RIGHTARG = public.eql_v3_jsonb_entry, + LEFTARG = public.eql_v3_json_entry, + RIGHTARG = public.eql_v3_json_entry, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); ---! @file v3/jsonb/blockers.sql ---! @brief Native-jsonb firewall for public.eql_v3_json. +--! @file v3/json/blockers.sql +--! @brief Native-jsonb firewall for public.eql_v3_json_search. --! ---! public.eql_v3_json SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons ---! = <> < <= > >= are supported on public.eql_v3_jsonb_entry only, not on the root +--! public.eql_v3_json_search SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons +--! = <> < <= > >= are supported on public.eql_v3_json_entry only, not on the root --! document domain. --! Every OTHER native jsonb operator reachable via domain fallback against the --! base type jsonb is BLOCKED here so an encrypted column can never silently @@ -43333,417 +46119,417 @@ CREATE OPERATOR >= ( --! so the firewall fires. --! @brief Blocker: ? (key/element exists). ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b text Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists(a public.eql_v3_json, b text) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists(a public.eql_v3_json_search, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '?'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR ? ( FUNCTION = eql_v3_internal.jsonb_blocked_exists, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = text ); --! @brief Blocker: ?| (any key exists). ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b text[] Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_any(a public.eql_v3_json, b text[]) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_any(a public.eql_v3_json_search, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '?|'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?|'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal.jsonb_blocked_exists_any, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = text[] ); --! @brief Blocker: ?& (all keys exist). ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b text[] Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_all(a public.eql_v3_json, b text[]) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_all(a public.eql_v3_json_search, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '?&'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?&'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal.jsonb_blocked_exists_all, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = text[] ); --! @brief Blocker: @? (jsonpath exists). ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b jsonpath Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_exists(a public.eql_v3_json, b jsonpath) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_exists(a public.eql_v3_json_search, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '@?'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@?'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR @? ( FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_exists, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = jsonpath ); --! @brief Blocker: @@ (jsonpath predicate). ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b jsonpath Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_match(a public.eql_v3_json, b jsonpath) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_match(a public.eql_v3_json_search, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '@@'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@@'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_match, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = jsonpath ); --! @brief Blocker: #> (path extract, native returns jsonb). ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b text[] Native RHS operand. --! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract(a public.eql_v3_json, b text[]) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract(a public.eql_v3_json_search, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '#>'); + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '#>'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR #> ( FUNCTION = eql_v3_internal.jsonb_blocked_path_extract, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = text[] ); --! @brief Blocker: #>> (path extract as text). ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b text[] Native RHS operand. --! @return text Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract_text(a public.eql_v3_json, b text[]) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract_text(a public.eql_v3_json_search, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_text('public.eql_v3_json', '#>>'); + RETURN eql_v3_internal.encrypted_domain_unsupported_text('public.eql_v3_json_search', '#>>'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal.jsonb_blocked_path_extract_text, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = text[] ); --! @brief Blocker: - (delete key, text RHS; native returns jsonb). ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b text Native RHS operand. --! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_text(a public.eql_v3_json, b text) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_text(a public.eql_v3_json_search, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '-'); + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR - ( FUNCTION = eql_v3_internal.jsonb_blocked_delete_text, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = text ); --! @brief Blocker: - (delete index, integer RHS). ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b integer Native RHS operand. --! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_int(a public.eql_v3_json, b integer) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_int(a public.eql_v3_json_search, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '-'); + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR - ( FUNCTION = eql_v3_internal.jsonb_blocked_delete_int, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = integer ); --! @brief Blocker: - (delete keys, text[] RHS). ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b text[] Native RHS operand. --! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_array(a public.eql_v3_json, b text[]) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_array(a public.eql_v3_json_search, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '-'); + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR - ( FUNCTION = eql_v3_internal.jsonb_blocked_delete_array, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = text[] ); --! @brief Blocker: #- (delete at path). ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b text[] Native RHS operand. --! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_path(a public.eql_v3_json, b text[]) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_path(a public.eql_v3_json_search, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '#-'); + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '#-'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR #- ( FUNCTION = eql_v3_internal.jsonb_blocked_delete_path, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = text[] ); --! @brief Blocker: || (concatenate, encrypted on the left). ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b jsonb Native RHS operand. --! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_concat(a public.eql_v3_json, b jsonb) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_concat(a public.eql_v3_json_search, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '||'); + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '||'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR || ( FUNCTION = eql_v3_internal.jsonb_blocked_concat, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = jsonb ); --! @brief Blocker: || (concatenate, encrypted on the right). --! @param a jsonb Native LHS operand. ---! @param b public.eql_v3_json Right operand (encrypted payload). +--! @param b public.eql_v3_json_search Right operand (encrypted payload). --! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_concat_rhs(a jsonb, b public.eql_v3_json) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_concat_rhs(a jsonb, b public.eql_v3_json_search) RETURNS jsonb IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '||'); + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '||'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR || ( FUNCTION = eql_v3_internal.jsonb_blocked_concat_rhs, LEFTARG = jsonb, - RIGHTARG = public.eql_v3_json + RIGHTARG = public.eql_v3_json_search ); ------------------------------------------------------------------------------ -- Root-document comparison blockers. ------------------------------------------------------------------------------ ---! @brief Blocker: root public.eql_v3_json document comparisons. ---! @param a public.eql_v3_json Left operand (encrypted payload). ---! @param b public.eql_v3_json Right operand (encrypted payload). +--! @brief Blocker: root public.eql_v3_json_search document comparisons. +--! @param a public.eql_v3_json_search Left operand (encrypted payload). +--! @param b public.eql_v3_json_search Right operand (encrypted payload). --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_json(a public.eql_v3_json, b public.eql_v3_json) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_json(a public.eql_v3_json_search, b public.eql_v3_json_search) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', 'comparison'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison'); END; $$ LANGUAGE plpgsql; ---! @brief Blocker: root public.eql_v3_json-to-jsonb comparisons. ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @brief Blocker: root public.eql_v3_json_search-to-jsonb comparisons. +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b jsonb Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_jsonb(a public.eql_v3_json, b jsonb) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_jsonb(a public.eql_v3_json_search, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', 'comparison'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison'); END; $$ LANGUAGE plpgsql; ---! @brief Blocker: root jsonb-to-public.eql_v3_json comparisons. +--! @brief Blocker: root jsonb-to-public.eql_v3_json_search comparisons. --! @param a jsonb Native LHS operand. ---! @param b public.eql_v3_json Right operand (encrypted payload). +--! @param b public.eql_v3_json_search Right operand (encrypted payload). --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_jsonb_json(a jsonb, b public.eql_v3_json) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_jsonb_json(a jsonb, b public.eql_v3_json_search) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', 'comparison'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR = ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = public.eql_v3_json, - RIGHTARG = public.eql_v3_json + LEFTARG = public.eql_v3_json_search, + RIGHTARG = public.eql_v3_json_search ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = jsonb ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, LEFTARG = jsonb, - RIGHTARG = public.eql_v3_json + RIGHTARG = public.eql_v3_json_search ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = public.eql_v3_json, - RIGHTARG = public.eql_v3_json + LEFTARG = public.eql_v3_json_search, + RIGHTARG = public.eql_v3_json_search ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = jsonb ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, LEFTARG = jsonb, - RIGHTARG = public.eql_v3_json + RIGHTARG = public.eql_v3_json_search ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = public.eql_v3_json, - RIGHTARG = public.eql_v3_json + LEFTARG = public.eql_v3_json_search, + RIGHTARG = public.eql_v3_json_search ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, LEFTARG = jsonb, - RIGHTARG = public.eql_v3_json + RIGHTARG = public.eql_v3_json_search ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = public.eql_v3_json, - RIGHTARG = public.eql_v3_json + LEFTARG = public.eql_v3_json_search, + RIGHTARG = public.eql_v3_json_search ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, LEFTARG = jsonb, - RIGHTARG = public.eql_v3_json + RIGHTARG = public.eql_v3_json_search ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = public.eql_v3_json, - RIGHTARG = public.eql_v3_json + LEFTARG = public.eql_v3_json_search, + RIGHTARG = public.eql_v3_json_search ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, LEFTARG = jsonb, - RIGHTARG = public.eql_v3_json + RIGHTARG = public.eql_v3_json_search ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = public.eql_v3_json, - RIGHTARG = public.eql_v3_json + LEFTARG = public.eql_v3_json_search, + RIGHTARG = public.eql_v3_json_search ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, LEFTARG = jsonb, - RIGHTARG = public.eql_v3_json + RIGHTARG = public.eql_v3_json_search ); ------------------------------------------------------------------------------ @@ -43751,197 +46537,83 @@ CREATE OPERATOR >= ( ------------------------------------------------------------------------------ --! @brief Blocker: @> with encrypted root document and native jsonb. ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b jsonb Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_json_jsonb(a public.eql_v3_json, b jsonb) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_json_jsonb(a public.eql_v3_json_search, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '@>'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@>'); END; $$ LANGUAGE plpgsql; --! @brief Blocker: @> with native jsonb and encrypted root document. --! @param a jsonb Native LHS operand. ---! @param b public.eql_v3_json Right operand (encrypted payload). +--! @param b public.eql_v3_json_search Right operand (encrypted payload). --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_jsonb_json(a jsonb, b public.eql_v3_json) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_jsonb_json(a jsonb, b public.eql_v3_json_search) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '@>'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@>'); END; $$ LANGUAGE plpgsql; --! @brief Blocker: <@ with encrypted root document and native jsonb. ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b jsonb Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_json_jsonb(a public.eql_v3_json, b jsonb) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_json_jsonb(a public.eql_v3_json_search, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '<@'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '<@'); END; $$ LANGUAGE plpgsql; --! @brief Blocker: <@ with native jsonb and encrypted root document. --! @param a jsonb Native LHS operand. ---! @param b public.eql_v3_json Right operand (encrypted payload). +--! @param b public.eql_v3_json_search Right operand (encrypted payload). --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_jsonb_json(a jsonb, b public.eql_v3_json) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_jsonb_json(a jsonb, b public.eql_v3_json_search) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '<@'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '<@'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.jsonb_blocked_contains_json_jsonb, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.jsonb_blocked_contains_jsonb_json, LEFTARG = jsonb, - RIGHTARG = public.eql_v3_json + RIGHTARG = public.eql_v3_json_search ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.jsonb_blocked_contained_json_jsonb, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.jsonb_blocked_contained_jsonb_json, LEFTARG = jsonb, - RIGHTARG = public.eql_v3_json -); - ---! @file v3/jsonb/aggregates.sql ---! @brief min / max aggregates over public.eql_v3_jsonb_entry. ---! ---! SteVec document entries extracted at a selector (`doc -> 'sel'`) order by ---! their CLLW OPE (`op`) term, so the extremum is picked by comparing ---! `eql_v3.ord_term(entry)` rather than the scalar Block-ORE `ord_term` the ---! generated scalar ord aggregates use. The ope_cllw bytea domain orders under ---! native byte comparison, so `<` / `>` on the extracted terms needs no custom ---! comparator. Same STRICT + PARALLEL SAFE shape as the generated scalar ---! `min`/`max` so partial/parallel aggregation is available on large GROUP BY ---! workloads. ---! ---! Per the encrypted-domain footgun rules the state functions are ---! `LANGUAGE plpgsql` with the pinned `search_path` — a `LANGUAGE sql` body would ---! be inlinable and the planner could elide it. ---! ---! @note **Only `op`-carrying entries are orderable.** `eql_v3.ord_term(entry)` ---! returns NULL when an entry has no `op` (CLLW OPE) term — the same entries a ---! `eql_v3.ord_term` btree NULL-filters from range scans. The state functions ---! therefore IGNORE `op`-less entries (they never become or survive as the ---! extremum), so `min`/`max` is well-defined over a mix of `op`-carrying and ---! `op`-less entries and is not corrupted by an `op`-less seed. A naive ---! `ord_term(value) < ord_term(state)` would be NULL whenever either side ---! lacks `op`, pinning a wrong (`op`-less) extremum when the first aggregated ---! row is `op`-less. An all-`op`-less input has no orderable extremum and ---! returns the (arbitrary) STRICT seed. - ---! @brief State function for min on public.eql_v3_jsonb_entry. ---! ---! Keeps whichever orderable entry has the lesser CLLW OPE term. STRICT, so SQL ---! NULL entries are skipped by the aggregate machinery; `op`-less (non-orderable) ---! entries are skipped explicitly (see the @note on this file). ---! ---! @param state public.eql_v3_jsonb_entry Running extremum. ---! @param value public.eql_v3_jsonb_entry Candidate entry. ---! @return public.eql_v3_jsonb_entry The lesser orderable entry by `ord_term`. -CREATE FUNCTION eql_v3_internal.jsonb_entry_min_sfunc( - state public.eql_v3_jsonb_entry, - value public.eql_v3_jsonb_entry -) -RETURNS public.eql_v3_jsonb_entry -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -DECLARE - value_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(value); - state_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(state); -BEGIN - -- A non-orderable (op-less) candidate never replaces the running extremum. - IF value_ope IS NULL THEN - RETURN state; - END IF; - -- Adopt the candidate when the running extremum is itself non-orderable - -- (e.g. an op-less STRICT seed) or strictly greater. - IF state_ope IS NULL OR value_ope < state_ope THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate over public.eql_v3_jsonb_entry. ---! @param input public.eql_v3_jsonb_entry ---! @return public.eql_v3_jsonb_entry The entry with the smallest CLLW OPE term. -CREATE AGGREGATE eql_v3.min(public.eql_v3_jsonb_entry) ( - sfunc = eql_v3_internal.jsonb_entry_min_sfunc, - stype = public.eql_v3_jsonb_entry, - combinefunc = eql_v3_internal.jsonb_entry_min_sfunc, - parallel = safe -); - ---! @brief State function for max on public.eql_v3_jsonb_entry. ---! ---! Keeps whichever orderable entry has the greater CLLW OPE term. `op`-less ---! entries are skipped, mirroring `jsonb_entry_min_sfunc` (see the file @note). ---! ---! @param state public.eql_v3_jsonb_entry Running extremum. ---! @param value public.eql_v3_jsonb_entry Candidate entry. ---! @return public.eql_v3_jsonb_entry The greater orderable entry by `ord_term`. -CREATE FUNCTION eql_v3_internal.jsonb_entry_max_sfunc( - state public.eql_v3_jsonb_entry, - value public.eql_v3_jsonb_entry -) -RETURNS public.eql_v3_jsonb_entry -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -DECLARE - value_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(value); - state_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(state); -BEGIN - -- A non-orderable (op-less) candidate never replaces the running extremum. - IF value_ope IS NULL THEN - RETURN state; - END IF; - -- Adopt the candidate when the running extremum is itself non-orderable - -- (e.g. an op-less STRICT seed) or strictly lesser. - IF state_ope IS NULL OR value_ope > state_ope THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate over public.eql_v3_jsonb_entry. ---! @param input public.eql_v3_jsonb_entry ---! @return public.eql_v3_jsonb_entry The entry with the largest CLLW OPE term. -CREATE AGGREGATE eql_v3.max(public.eql_v3_jsonb_entry) ( - sfunc = eql_v3_internal.jsonb_entry_max_sfunc, - stype = public.eql_v3_jsonb_entry, - combinefunc = eql_v3_internal.jsonb_entry_max_sfunc, - parallel = safe + RIGHTARG = public.eql_v3_json_search ); --! @file pin_search_path_v3.sql --! @brief Post-install: pin search_path on every eql_v3.* function. diff --git a/crates/eql-bindings/sql/release-manifest.json b/crates/eql-bindings/sql/release-manifest.json index cf5e0e28d..b27c45e21 100644 --- a/crates/eql-bindings/sql/release-manifest.json +++ b/crates/eql-bindings/sql/release-manifest.json @@ -1,6 +1,6 @@ { "eqlVersion": "3.0.0", "schemaVersion": 3, - "installSqlSha256": "9311a0c9faeaebe1397fba2abf9e581ce006e94bbd0255596c21e5ada5245afa", + "installSqlSha256": "6da5ed462b02f53a0636d783880533496eecfb52218d718791085376bc44c6a0", "uninstallSqlSha256": "b1b5131b8175c5d04da9ada108d25c81c5772b15fad79a6c419ebb32d18c60a9" } diff --git a/crates/eql-bindings/src/v3/terms.rs b/crates/eql-bindings/src/v3/terms.rs index 8a39902d2..04b8a3ab5 100644 --- a/crates/eql-bindings/src/v3/terms.rs +++ b/crates/eql-bindings/src/v3/terms.rs @@ -57,8 +57,9 @@ pub struct OpeCllw(pub String); #[ts(export, export_to = "v3/")] pub struct OreBlock256(pub Vec); -/// Bloom-filter match term — the `bf` wire key. Backs the `_match` domains -/// (`@>`/`<@` containment). +/// Bloom-filter match term — the `bf` wire key. Backs the fuzzy-match `@@` +/// (`eql_v3.matches`) surface on the `_match` domains; the containment operators +/// `@>`/`<@` survive only as internal blockers that raise (CIP-3517). /// /// **Signed** i16, not u16: EQL stores the filter as PostgreSQL `smallint[]`, /// and filters sized above 32768 emit upper-half bit positions as negative @@ -89,8 +90,10 @@ impl schemars::JsonSchema for BloomFilter { "minimum": i16::MIN, "maximum": i16::MAX, }, - "description": "Bloom-filter match term — the `bf` wire key. Backs the `_match` \ - domains (`@>`/`<@` containment). Signed i16: EQL stores the filter \ + "description": "Bloom-filter match term — the `bf` wire key. Backs the fuzzy-match \ + `@@` (`eql_v3.matches`) surface on the `_match` domains; the \ + containment operators `@>`/`<@` survive only as internal blockers \ + that raise (CIP-3517). Signed i16: EQL stores the filter \ as PostgreSQL `smallint[]`, and filters sized above 32768 emit \ upper-half bit positions as negative signed values.", }) diff --git a/crates/eql-bindings/src/v3/text.rs b/crates/eql-bindings/src/v3/text.rs index b108ffaa6..de7ce7b2c 100644 --- a/crates/eql-bindings/src/v3/text.rs +++ b/crates/eql-bindings/src/v3/text.rs @@ -71,7 +71,7 @@ impl DomainType for TextEq { } /// `public.eql_v3_text_match` — match domain. /// -/// Operators: `@>` `<@`. Required keys: `v` `i` `c` `bf`. +/// Operators: `@@`. Required keys: `v` `i` `c` `bf`. #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)] #[ts(export, export_to = "v3/")] #[serde(deny_unknown_fields)] @@ -202,7 +202,7 @@ impl DomainType for TextOrdOpe { } /// `public.eql_v3_text_search_ore` — search domain. /// -/// Operators: `=` `<>` `<` `<=` `>` `>=` `@>` `<@`. Required keys: `v` `i` `c` `hm` `ob` `bf`. +/// Operators: `=` `<>` `<` `<=` `>` `>=` `@@`. Required keys: `v` `i` `c` `hm` `ob` `bf`. #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)] #[ts(export, export_to = "v3/")] #[serde(deny_unknown_fields)] @@ -236,7 +236,7 @@ impl DomainType for TextSearchOre { } /// `public.eql_v3_text_search` — search domain. /// -/// Operators: `=` `<>` `<` `<=` `>` `>=` `@>` `<@`. Required keys: `v` `i` `c` `hm` `op` `bf`. +/// Operators: `=` `<>` `<` `<=` `>` `>=` `@@`. Required keys: `v` `i` `c` `hm` `op` `bf`. #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)] #[ts(export, export_to = "v3/")] #[serde(deny_unknown_fields)] @@ -301,7 +301,7 @@ impl DomainType for TextEqQuery { } /// `eql_v3.query_text_match` — match domain query operand. /// -/// Operators: `@>` `<@`. Required keys: `v` `i` `bf`. +/// Operators: `@@`. Required keys: `v` `i` `bf`. #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)] #[ts(export, export_to = "v3/")] #[serde(deny_unknown_fields)] @@ -428,7 +428,7 @@ impl DomainType for TextOrdOpeQuery { } /// `eql_v3.query_text_search_ore` — search domain query operand. /// -/// Operators: `=` `<>` `<` `<=` `>` `>=` `@>` `<@`. Required keys: `v` `i` `hm` `ob` `bf`. +/// Operators: `=` `<>` `<` `<=` `>` `>=` `@@`. Required keys: `v` `i` `hm` `ob` `bf`. #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)] #[ts(export, export_to = "v3/")] #[serde(deny_unknown_fields)] @@ -461,7 +461,7 @@ impl DomainType for TextSearchOreQuery { } /// `eql_v3.query_text_search` — search domain query operand. /// -/// Operators: `=` `<>` `<` `<=` `>` `>=` `@>` `<@`. Required keys: `v` `i` `hm` `op` `bf`. +/// Operators: `=` `<>` `<` `<=` `>` `>=` `@@`. Required keys: `v` `i` `hm` `op` `bf`. #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)] #[ts(export, export_to = "v3/")] #[serde(deny_unknown_fields)] diff --git a/crates/eql-codegen/src/bindings.rs b/crates/eql-codegen/src/bindings.rs index 1a8ee339a..9ca54cddb 100644 --- a/crates/eql-codegen/src/bindings.rs +++ b/crates/eql-codegen/src/bindings.rs @@ -939,7 +939,7 @@ mod tests { let text = render_family_bindings(family("text")); assert!(text.contains("Required keys: `v` `i` `c` `hm` `ob`.")); assert!(text.contains("`public.eql_v3_text_match` — match domain.")); - assert!(text.contains("Operators: `@>` `<@`.")); + assert!(text.contains("Operators: `@@`.")); assert!(text.contains("Required keys: `v` `i` `c` `bf`.")); } diff --git a/crates/eql-codegen/src/context.rs b/crates/eql-codegen/src/context.rs index e6e5018f7..0fe6b7722 100644 --- a/crates/eql-codegen/src/context.rs +++ b/crates/eql-codegen/src/context.rs @@ -101,8 +101,8 @@ fn capability_phrase(domain: &Domain) -> String { if ops.contains(&"<") { caps.push("ordering"); } - if ops.contains(&"@>") { - caps.push("containment"); + if ops.contains(&"@@") { + caps.push("matching"); } if caps.is_empty() { "storage only".to_string() @@ -263,8 +263,11 @@ pub fn wrapper_entry( extractor: &str, ) -> FnEntry { FnEntry::Wrapper { - op: op.symbol.to_string(), - function_name: op.function_name.to_string(), + // Body operator: `symbol` for all but `@@`, whose body uses bloom `@>`. + op: op.body_operator().to_string(), + // Supported path → the public wrapper name. Differs from `function_name` + // (the blocker name) only for `@@`, whose wrapper is `eql_v3.matches`. + function_name: op.wrapper_function_name().to_string(), args: [ SqlParam { name: "a", @@ -333,9 +336,16 @@ pub fn operator_entry(op: &Operator, leftarg: &str, rightarg: &str, supported: b // Some`, so `render_functions_file` always emits a wrapper for a supported // operator and a blocker otherwise. let function_schema = if supported { SCHEMA } else { INTERNAL_SCHEMA }; + // Supported → the public wrapper name (`eql_v3.matches` for `@@`); blocked → + // the blocker name (`eql_v3_internal."@@"`). They differ only for `@@`. + let function_name = if supported { + op.wrapper_function_name() + } else { + op.function_name + }; OpEntry { symbol: op.symbol.to_string(), - function_name: op.function_name.to_string(), + function_name: function_name.to_string(), function_schema: function_schema.to_string(), leftarg: leftarg.to_string(), rightarg: rightarg.to_string(), @@ -515,16 +525,26 @@ mod tests { ("=", "public.eql_v3_integer", false, None), // Supported but metadata-less operator (`->`) → still no metadata. ("->", "public.eql_v3_integer_eq", true, None), - // `@>` carries containment metadata when supported (the Bloom - // `text_match` path). + // `@@` (bloom fuzzy match) carries containment-style selectivity when + // supported (the Bloom `text_match` path) — no commutator/negator, so + // just the RESTRICT/JOIN estimators. + ( + "@@", + "public.eql_v3_text_match", + true, + Some("RESTRICT = contsel, JOIN = contjoinsel"), + ), + // `@>` carries containment metadata when explicitly supported (retained + // for the hand-written JSON containment surface; the generated scalar + // catalog no longer marks `@>` supported on any domain). ( "@>", "public.eql_v3_text_match", true, Some("COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel"), ), - // ... but suppressed when `@>` is a blocker (non-Bloom domains), - // which is why the integer reference is unchanged. + // ... but suppressed when `@>` is a blocker (its actual catalog state + // on every domain now), which is why the integer reference is unchanged. ("@>", "public.eql_v3_integer_eq", false, None), ]; diff --git a/crates/eql-codegen/src/generate.rs b/crates/eql-codegen/src/generate.rs index 5093b7301..c359e5450 100644 --- a/crates/eql-codegen/src/generate.rs +++ b/crates/eql-codegen/src/generate.rs @@ -120,7 +120,9 @@ pub fn render_functions_file(family_name: &str, domain: &Domain) -> String { let extractor = Term::extractor_for_operator(domain.terms, op.symbol); for sig in op.signatures { let rendered = sig.render(&dom); - if is_supported(op.symbol) { + // A `blocker_only` overload (the `@@` jsonpath predicate) always falls + // through to the blocker, even when the domain supports the symbol. + if is_supported(op.symbol) && !sig.blocker_only { if let Some(ex) = extractor { entries.push(wrapper_entry(&dom, op, &rendered.left, &rendered.right, ex)); continue; @@ -169,11 +171,13 @@ pub fn render_operators_file(family_name: &str, domain: &Domain) -> String { // CREATE OPERATOR only needs the operand types; `rendered.returns` is // intentionally discarded here (it matters only for the function body). let rendered = sig.render(&dom); + // A `blocker_only` overload (the `@@` jsonpath predicate) is bound to + // the internal blocker even on a domain that supports the symbol. operators.push(operator_entry( op, &rendered.left, &rendered.right, - is_supported(op.symbol), + is_supported(op.symbol) && !sig.blocker_only, )); } } @@ -949,9 +953,12 @@ mod tests { fn storage_functions_file_is_all_blockers() { let s = spec("integer"); let sql = render_functions_file(s.name, domain(s, "")); - assert_eq!(sql.matches("CREATE FUNCTION").count(), 44); + // 44 native/comparison blockers + 3 `@@` symmetric-match blockers (a + // storage domain supports no operators, so `@@`'s match overloads render + // as blockers, exactly like `@>`/`<@`). + assert_eq!(sql.matches("CREATE FUNCTION").count(), 47); assert!(!sql.contains("SET search_path")); - assert_eq!(sql.matches("LANGUAGE plpgsql").count(), 44); + assert_eq!(sql.matches("LANGUAGE plpgsql").count(), 47); assert_eq!( sql.matches("LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE") .count(), @@ -963,7 +970,9 @@ mod tests { fn eq_functions_file_counts() { let s = spec("integer"); let sql = render_functions_file(s.name, domain(s, "eq")); - assert_eq!(sql.matches("CREATE FUNCTION").count(), 45); + // +3 vs the pre-`@@`-match surface: the three `@@` symmetric-match + // overloads render as blockers on this eq domain (it does not carry Bloom). + assert_eq!(sql.matches("CREATE FUNCTION").count(), 48); assert!(sql.contains("CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_integer_eq)")); assert!(sql.contains("RETURNS eql_v3_internal.hmac_256")); assert_eq!( @@ -971,7 +980,7 @@ mod tests { .count(), 7 ); - assert_eq!(sql.matches("LANGUAGE plpgsql").count(), 38); + assert_eq!(sql.matches("LANGUAGE plpgsql").count(), 41); assert!(!sql.contains("SET search_path")); } @@ -981,7 +990,8 @@ mod tests { fn ore_functions_file_counts() { let s = spec("integer"); let sql = render_functions_file(s.name, domain(s, "ord_ore")); - assert_eq!(sql.matches("CREATE FUNCTION").count(), 45); + // +3 vs the pre-`@@`-match surface (the three `@@` symmetric-match blockers). + assert_eq!(sql.matches("CREATE FUNCTION").count(), 48); assert!( sql.contains("CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_integer_ord_ore)") ); @@ -994,7 +1004,7 @@ mod tests { .count(), 19 ); - assert_eq!(sql.matches("LANGUAGE plpgsql").count(), 26); + assert_eq!(sql.matches("LANGUAGE plpgsql").count(), 29); } /// The OPE ordered domains mirror the ORE one — same operator surface @@ -1012,7 +1022,8 @@ mod tests { let s = spec("integer"); for dom in ["ord", "ord_ope"] { let sql = render_functions_file(s.name, domain(s, dom)); - assert_eq!(sql.matches("CREATE FUNCTION").count(), 45, "{dom}"); + // +3 vs the pre-`@@`-match surface (the three `@@` symmetric-match blockers). + assert_eq!(sql.matches("CREATE FUNCTION").count(), 48, "{dom}"); assert!( sql.contains(&format!( "CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_integer_{dom})" @@ -1034,15 +1045,49 @@ mod tests { 19, "{dom}" ); - assert_eq!(sql.matches("LANGUAGE plpgsql").count(), 26, "{dom}"); + assert_eq!(sql.matches("LANGUAGE plpgsql").count(), 29, "{dom}"); } } #[test] - fn operators_file_has_forty_four() { + fn match_domain_renders_matches_wrapper_and_at_at_operator() { + let s = spec("text"); + let fns = render_functions_file(s.name, domain(s, "match")); + // The supported `@@` overloads are `eql_v3.matches` wrappers whose body + // reduces to bloom array-containment `@>` on the extracted terms (so a + // functional GIN index on `eql_v3.match_term(col)` engages). + assert!(fns.contains( + "CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b public.eql_v3_text_match)" + )); + assert!(fns.contains("SELECT eql_v3.match_term(a) @> eql_v3.match_term(b)")); + assert!(!fns.contains("eql_v3.contains(")); + assert!(!fns.contains("eql_v3.contained_by(")); + // `@>` / `<@` are now blockers on the match domain. + assert!(fns.contains( + "CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_match, b public.eql_v3_text_match)" + )); + assert!(fns.contains( + "CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_match, b public.eql_v3_text_match)" + )); + // The `@@` jsonpath predicate stays a blocker even here (blocker_only). + assert!(fns.contains( + "CREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_match, b jsonpath)" + )); + + let ops = render_operators_file(s.name, domain(s, "match")); + assert!(ops.contains("CREATE OPERATOR @@ (")); + assert!(ops.contains("FUNCTION = eql_v3.matches,")); + // The jsonpath `@@` operator binds the internal blocker. + assert!(ops.contains("FUNCTION = eql_v3_internal.\"@@\",")); + } + + #[test] + fn operators_file_operator_count() { let s = spec("integer"); let sql = render_operators_file(s.name, domain(s, "eq")); - assert_eq!(sql.matches("CREATE OPERATOR").count(), 44); + // +3 vs the pre-`@@`-match surface: the three `@@` symmetric-match + // overloads render as blocked operators on this eq domain. + assert_eq!(sql.matches("CREATE OPERATOR").count(), 47); } #[test] @@ -1082,11 +1127,13 @@ mod tests { ); } - // Bloom text_match: containment wrappers are supported → public. + // Bloom text_match: the `@@` fuzzy-match wrapper is supported → public; + // the former containment operators `@>`/`<@` are now blockers (internal). let tm = spec("text"); let tm_sql = render_operators_file(tm.name, domain(tm, "match")); - assert!(tm_sql.contains("FUNCTION = eql_v3.contains,")); - assert!(tm_sql.contains("FUNCTION = eql_v3.contained_by,")); + assert!(tm_sql.contains("FUNCTION = eql_v3.matches,")); + assert!(tm_sql.contains("FUNCTION = eql_v3_internal.contains,")); + assert!(tm_sql.contains("FUNCTION = eql_v3_internal.contained_by,")); } #[test] @@ -1176,13 +1223,15 @@ mod tests { .1 }; assert!(by("json_types.sql").contains("CREATE DOMAIN public.eql_v3_json AS jsonb")); + // Storage-only (no terms) → every operator overload is a blocker, incl. + // the three `@@` symmetric-match overloads (+3 vs the pre-match surface). assert_eq!( by("json_functions.sql").matches("CREATE FUNCTION").count(), - 44 + 47 ); assert_eq!( by("json_operators.sql").matches("CREATE OPERATOR").count(), - 44 + 47 ); } diff --git a/crates/eql-codegen/src/operator_surface.rs b/crates/eql-codegen/src/operator_surface.rs index 6e47c0aef..9aa75bf02 100644 --- a/crates/eql-codegen/src/operator_surface.rs +++ b/crates/eql-codegen/src/operator_surface.rs @@ -60,7 +60,7 @@ impl OperatorMetadata { /// A type position in a PostgreSQL operator overload. `Domain` renders to the /// concrete encrypted domain being generated; every other slot renders to a /// fixed PostgreSQL type name. -#[derive(Clone, Copy, PartialEq, Eq)] +#[derive(Clone, Copy, PartialEq, Eq, Debug)] pub enum TypeSlot { Domain, Jsonb, @@ -92,6 +92,14 @@ pub struct OperatorSignature { pub left: TypeSlot, pub right: TypeSlot, pub returns: TypeSlot, + /// When true this overload is ALWAYS rendered as a blocker, even on a domain + /// whose terms otherwise support the operator's symbol. The only user is the + /// `@@` `(domain, jsonpath)` native-jsonb-predicate overload: `@@` is the + /// SUPPORTED bloom fuzzy-match operator on match domains for its symmetric + /// domain/jsonb overloads, but its jsonpath overload must keep raising (the + /// "no silent native jsonb ops" guarantee) on every domain including the + /// match domains. Normal operators leave this `false`. + pub blocker_only: bool, } /// An `OperatorSignature` with every slot resolved to a concrete SQL type name. @@ -117,6 +125,17 @@ const fn sig(left: TypeSlot, right: TypeSlot, returns: TypeSlot) -> OperatorSign left, right, returns, + blocker_only: false, + } +} + +/// Constructor for an always-blocked overload (see `OperatorSignature::blocker_only`). +const fn sig_blocker(left: TypeSlot, right: TypeSlot, returns: TypeSlot) -> OperatorSignature { + OperatorSignature { + left, + right, + returns, + blocker_only: true, } } @@ -153,10 +172,24 @@ const HAS_ANY_KEYS_SIGNATURES: &[OperatorSignature] = &[sig( TypeSlot::Boolean, )]; -/// `@?` / `@@` jsonpath-predicate overloads. +/// `@?` jsonpath-predicate overload (also the shape `@@` blocks on non-match +/// domains — see `MATCH_SIGNATURES`). const JSONPATH_SIGNATURES: &[OperatorSignature] = &[sig(TypeSlot::Domain, TypeSlot::Jsonpath, TypeSlot::Boolean)]; +/// `@@` bloom fuzzy-match overloads: the symmetric domain/jsonb match shapes +/// (SUPPORTED on Bloom-carrying domains, backed by `eql_v3.matches`), plus the +/// native-jsonb `(domain, jsonpath)` predicate overload marked `blocker_only` +/// so it keeps raising on every domain (including match domains). On non-Bloom +/// domains all four render as blockers, exactly as `@>`/`<@` do for a domain +/// that does not support containment. +const MATCH_SIGNATURES: &[OperatorSignature] = &[ + sig(TypeSlot::Domain, TypeSlot::Domain, TypeSlot::Boolean), + sig(TypeSlot::Domain, TypeSlot::Jsonb, TypeSlot::Boolean), + sig(TypeSlot::Jsonb, TypeSlot::Domain, TypeSlot::Boolean), + sig_blocker(TypeSlot::Domain, TypeSlot::Jsonpath, TypeSlot::Boolean), +]; + /// `#>` path-extract overload (returns jsonb). const PATH_EXTRACT_JSONB_SIGNATURES: &[OperatorSignature] = &[sig(TypeSlot::Domain, TypeSlot::TextArray, TypeSlot::Jsonb)]; @@ -213,6 +246,34 @@ impl Operator { && !CONTAINMENT.contains(&self.symbol) && !PATH_SELECTOR.contains(&self.symbol) } + + /// The name of the SUPPORTED comparison-wrapper function for this operator + /// (the `eql_v3.` public wrapper). Equal to `function_name` for every + /// operator except `@@`, whose supported form is the bloom fuzzy-match + /// `eql_v3.matches` while its blocked `(domain, jsonpath)` overload keeps the + /// blocker name `eql_v3_internal."@@"`. The blocker path always uses + /// `function_name`; only the wrapper/supported path calls this. + pub fn wrapper_function_name(&self) -> &'static str { + match self.symbol { + "@@" => "matches", + _ => self.function_name, + } + } + + /// The SQL operator used INSIDE the wrapper body + /// (`extractor(a) extractor(b)`). Equal to `symbol` for every + /// operator except `@@`, whose body performs bloom array-containment `@>` on + /// the extracted `eql_v3_internal.bloom_filter` (`smallint[]`) terms. So the + /// public `@@` fuzzy-match operator reduces, through inlining, to exactly the + /// GIN-indexable `match_term(col) @> match_term(needle)` expression the former + /// `contains` wrapper produced — no new operator on the SEM bloom_filter type, + /// and the proven single-level inline to the array `@>` GIN opclass is kept. + pub fn body_operator(&self) -> &'static str { + match self.symbol { + "@@" => "@>", + _ => self.symbol, + } + } } /// The native-jsonb operator symbols that every encrypted domain blocks, in @@ -253,6 +314,19 @@ const fn containment_metadata(commutator: &'static str) -> OperatorMetadata { } } +/// Match-operator metadata (`@@`): the bloom fuzzy-match is array containment +/// under the hood, so it reuses the containment selectivity estimators, but it +/// is a single directional operator with no reverse — hence no commutator and +/// no negator. +const fn match_metadata() -> OperatorMetadata { + OperatorMetadata { + restrict: Some("contsel"), + join: Some("contjoinsel"), + commutator: None, + negator: None, + } +} + /// The 20-operator catalog. Order is: comparison operators, then path-selector /// operators, then the remaining native jsonb operators. pub const OPERATORS: &[Operator] = &[ @@ -343,8 +417,8 @@ pub const OPERATORS: &[Operator] = &[ Operator { symbol: "@@", function_name: "\"@@\"", - signatures: JSONPATH_SIGNATURES, - metadata: OperatorMetadata::none(), + signatures: MATCH_SIGNATURES, + metadata: match_metadata(), }, Operator { symbol: "#>", @@ -397,6 +471,7 @@ mod tests { left: TypeSlot::Domain, right: TypeSlot::Text, returns: TypeSlot::Boolean, + blocker_only: false, }; let rendered = sig.render("public.eql_v3_integer_eq"); assert_eq!(rendered.left, "public.eql_v3_integer_eq"); @@ -633,6 +708,45 @@ mod tests { ); } + #[test] + fn match_operator_carries_symmetric_and_blocker_only_signatures() { + // `@@` is the bloom fuzzy-match operator: three symmetric match overloads + // plus the always-blocked `(domain, jsonpath)` native-jsonb predicate. + let at_at = operator("@@"); + assert_eq!(at_at.signatures.len(), 4); + let symmetric: Vec<_> = at_at + .signatures + .iter() + .filter(|s| !s.blocker_only) + .map(|s| (s.left, s.right)) + .collect(); + assert_eq!( + symmetric, + vec![ + (TypeSlot::Domain, TypeSlot::Domain), + (TypeSlot::Domain, TypeSlot::Jsonb), + (TypeSlot::Jsonb, TypeSlot::Domain), + ] + ); + let blocker_only: Vec<_> = at_at + .signatures + .iter() + .filter(|s| s.blocker_only) + .map(|s| (s.left, s.right)) + .collect(); + assert_eq!(blocker_only, vec![(TypeSlot::Domain, TypeSlot::Jsonpath)]); + } + + #[test] + fn wrapper_function_name_overrides_only_for_match() { + // The supported wrapper for `@@` is `matches`; its blocker name stays + // `"@@"`. Every other operator's wrapper and blocker names coincide. + assert_eq!(operator("@@").wrapper_function_name(), "matches"); + assert_eq!(operator("@@").function_name, "\"@@\""); + assert_eq!(operator("=").wrapper_function_name(), "eq"); + assert_eq!(operator("@>").wrapper_function_name(), "contains"); + } + #[test] fn native_jsonb_blocker_symbols_are_the_residual_ten() { // The residual after removing the 6 comparison + 2 containment + 2 diff --git a/crates/eql-codegen/templates/functions/unsupported.sql.j2 b/crates/eql-codegen/templates/functions/unsupported.sql.j2 index 0efa3bbc1..de76fa1e6 100644 --- a/crates/eql-codegen/templates/functions/unsupported.sql.j2 +++ b/crates/eql-codegen/templates/functions/unsupported.sql.j2 @@ -1,7 +1,12 @@ --! @brief Unsupported operator blocker for {{ dom }}. ---! @param {{ e.args[0].name }} {{ e.args[0].ty }} ---! @param {{ e.args[1].name }} {{ e.args[1].ty }} ---! @return {{ e.returns }} +--! +--! Intercepts an operator that is not supported on {{ dom }} and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param {{ e.args[0].name }} {{ e.args[0].ty }} left operand of the blocked operator +--! @param {{ e.args[1].name }} {{ e.args[1].ty }} right operand of the blocked operator +--! @return {{ e.returns }} never returned — the function always raises "operator not supported" CREATE FUNCTION {{ internal_schema }}.{{ e.function_name }}({{ e.args[0].name }} {{ e.args[0].ty }}, {{ e.args[1].name }} {{ e.args[1].ty }}) RETURNS {{ e.returns }} IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '{{ e.operator_lit }}', '{{ domain_lit }}'; END; $$ diff --git a/crates/eql-domains/src/term.rs b/crates/eql-domains/src/term.rs index 370bf730e..64184cfc6 100644 --- a/crates/eql-domains/src/term.rs +++ b/crates/eql-domains/src/term.rs @@ -80,7 +80,7 @@ impl Term { match self { Term::Hm => &["=", "<>"], Term::Ore => &["=", "<>", "<", "<=", ">", ">="], - Term::Bloom => &["@>", "<@"], + Term::Bloom => &["@@"], Term::Ope => &["=", "<>", "<", "<=", ">", ">="], } } diff --git a/crates/eql-domains/src/tests.rs b/crates/eql-domains/src/tests.rs index 774ad646f..ad3f4d5e4 100644 --- a/crates/eql-domains/src/tests.rs +++ b/crates/eql-domains/src/tests.rs @@ -271,7 +271,7 @@ mod term_tests { assert_eq!(b.extractor(), "match_term"); assert_eq!(b.ctor(), "bloom_filter"); assert_eq!(b.role(), Role::Match); - assert_eq!(b.operators(), &["@>", "<@"]); + assert_eq!(b.operators(), &["@@"]); assert_eq!(b.requires(), &["src/v3/sem/bloom_filter/functions.sql"]); } @@ -315,13 +315,13 @@ mod term_tests { fn bloom_extractor_routes_match_operators() { let terms = &[Term::Bloom]; assert_eq!( - Term::extractor_for_operator(terms, "@>"), - Some("match_term") - ); - assert_eq!( - Term::extractor_for_operator(terms, "<@"), + Term::extractor_for_operator(terms, "@@"), Some("match_term") ); + // Containment operators are no longer routed by Bloom — the match + // domains use `@@`, and `@>`/`<@` fall through to blockers. + assert_eq!(Term::extractor_for_operator(terms, "@>"), None); + assert_eq!(Term::extractor_for_operator(terms, "<@"), None); assert_eq!(Term::extractor_for_operator(terms, "="), None); } @@ -832,7 +832,7 @@ mod catalog_tests { Some("ord_term") ); assert_eq!( - Term::extractor_for_operator(search.terms, "@>"), + Term::extractor_for_operator(search.terms, "@@"), Some("match_term") ); } @@ -878,7 +878,7 @@ mod catalog_tests { Some("ord_term_ore") ); assert_eq!( - Term::extractor_for_operator(search_ore.terms, "@>"), + Term::extractor_for_operator(search_ore.terms, "@@"), Some("match_term") ); } diff --git a/docs/reference/adding-a-scalar-encrypted-domain-type.md b/docs/reference/adding-a-scalar-encrypted-domain-type.md index d4dcbdfd4..ec95693db 100644 --- a/docs/reference/adding-a-scalar-encrypted-domain-type.md +++ b/docs/reference/adding-a-scalar-encrypted-domain-type.md @@ -163,7 +163,7 @@ behaviour change, not a refactor: | ------- | -------- | -------------- | -------------------------------- | -------------------------- | | `Hm` | `hm` | `eq_term` | `eql_v3_internal.hmac_256` | `=` `<>` | | `Ore` | `ob` | `ord_term_ore` | `eql_v3_internal.ore_block_256` | `=` `<>` `<` `<=` `>` `>=` | -| `Bloom` | `bf` | `match_term` | `eql_v3_internal.bloom_filter` | `@>` `<@` | +| `Bloom` | `bf` | `match_term` | `eql_v3_internal.bloom_filter` | `@@` | | `Ope` | `op` | `ord_term` | `eql_v3_internal.ope_cllw` | `=` `<>` `<` `<=` `>` `>=` | (`Ope` is the CLLW-OPE term: a hex-encoded, order-preserving ciphertext whose @@ -446,14 +446,14 @@ change the wide `numeric` / `timestamp` terms rely on. ### New-capability domains (e.g. `_match` / `Bloom`) A domain carrying a capability the matrix does not model — `text`'s `_match` -(`Bloom`, `@>`/`<@`) is the only example today — is **not** covered by the +(`Bloom`, `@@`) is the only example today — is **not** covered by the auto-generated `scalar_matrix!`, which only understands the eq/ord caps. So for such a domain you must, in addition to the catalog row: - **write hand-written behavioural suites** — see - `tests/sqlx/tests/encrypted_domain/text/text_match.rs` (fixture-backed - bloom-containment) and `text_smoke.rs` (literal-payload `@>`/`<@` engage, `=` - raises, `~~`/`~~*` absent, CHECK requires `bf`); + `tests/sqlx/tests/encrypted_domain/text/text_match.rs` (fixture-backed bloom + fuzzy match) and `text_smoke.rs` (literal-payload `@@` engages, `=`/`@>`/`<@` + raise, `~~`/`~~*` absent, CHECK requires `bf`); - **register them via `#[path]` mod declarations** in `tests/sqlx/tests/encrypted_domain.rs`, kept **outside** the `scalars::` module on purpose: the matrix-inventory gate treats every `scalars::::` prefix as a @@ -529,7 +529,7 @@ generated SQL committed under `src/v3/scalars//` (regenerate with per-type domain *shapes* differ — ordered types (including `timestamp`) carry `_ord`/`_ord_ore` + aggregates, a hypothetical equality-only type (`EQ_ONLY_DOMAINS`) would omit them, and the Bloom `text_match` domain renders -`@>`/`<@` as supported containment operators no ordered type emits — so +`@@` as the supported fuzzy-match operator no ordered type emits — so committing every type catches a regression in any shape, not just the ordered one. `committed_scalar_dirs_match_catalog_tokens` (in `crates/eql-codegen/tests/parity.rs`) fails CI if a catalog row has no committed @@ -597,16 +597,17 @@ Every generated domain declares supported scalar comparison operators plus blockers for the native `jsonb` operator surface PostgreSQL could otherwise reach through domain-to-base-type fallback. The surface is a fixed 20 operators (`crates/eql-codegen/src/operator_surface.rs`, `OPERATORS`), each with its -PostgreSQL-shaped signatures, summing to **44 `CREATE OPERATOR` statements per +PostgreSQL-shaped signatures, summing to **47 `CREATE OPERATOR` statements per domain**: | Operators | Forms | |---|---| -| `=` `<>` `<` `<=` `>` `>=` `@>` `<@` | `(domain, domain)` · `(domain, jsonb)` · `(jsonb, domain)` | +| `=` `<>` `<` `<=` `>` `>=` `@>` `<@` `@@` | `(domain, domain)` · `(domain, jsonb)` · `(jsonb, domain)` | | `->` `->>` | `(domain, text)` · `(domain, integer)` · `(jsonb, domain)` | | `?` | `(domain, text)` | | `?\|` `?&` | `(domain, text[])` | -| `@?` `@@` | `(domain, jsonpath)` | +| `@?` | `(domain, jsonpath)` | +| `@@` | `(domain, jsonpath)` — **blocker-only** (the native-jsonb predicate guard; always raises, even on match domains where the symmetric `@@` overloads above are the supported fuzzy match) | | `#>` `#>>` `#-` | `(domain, text[])` | | `-` | `(domain, text)` · `(domain, integer)` · `(domain, text[])` | | `\|\|` | `(domain, domain)` · `(domain, jsonb)` · `(jsonb, domain)` | @@ -617,42 +618,43 @@ the operator. Supported operators are emitted with full planner metadata (`COMMUTATOR`, `NEGATOR`, `RESTRICT`, `JOIN` selectivity estimators) backing onto inlinable wrappers; everything else carries minimal metadata backing onto blockers. Path operators always back onto blockers — neither current term -enables them — and the native `jsonb` operators are blocker-only **except -`@>`/`<@`**, which back onto inlinable containment wrappers (`eql_v3.contains` / -`eql_v3.contained_by`) on any domain carrying the `Bloom` term — the +enables them — and the native `jsonb` operators are blocker-only **except the +three symmetric `@@` overloads**, which back onto the inlinable bloom fuzzy-match +wrapper (`eql_v3.matches`) on any domain carrying the `Bloom` term — the single-capability `_match` domain (e.g. `public.eql_v3_text_match`) **and** the combined -`_search` domain (`public.eql_v3_text_search`, `[Hm, Ore, Bloom]`) — and elsewhere stay +`_search` domain (`public.eql_v3_text_search`, `[Hm, Ope, Bloom]`) — and elsewhere stay blockers — matching the per-domain table just below, where every `Bloom`-bearing -row carries six containment wrappers. +row carries three match wrappers. (`@>`/`<@` are **containment**, distinct from the +`@@` fuzzy match — CIP-3517 — and are blockers on every scalar domain.) -The wrapper/blocker split per domain (the 44-operator total never moves). A +The wrapper/blocker split per domain (the 47-operator total never moves). A domain's wrappers are the **union** of its terms' operators (`Term::operators_for_terms`), so a multi-term domain advertises every operator any of its terms provides; the rest stay blockers. `Functions` = -`44 + ` (one extractor function per distinct extractor): +`47 + ` (one extractor function per distinct extractor): | Domain terms | Extractors | Wrappers | Blockers | Functions | Operators | | ----------------- | ---------: | -------: | -------: | --------: | --------: | -| none | 0 | 0 | 44 | 44 | 44 | -| `&[Term::Hm]` | 1 (`eq_term`) | 6 | 38 | 45 | 44 | -| `&[Term::Bloom]` | 1 (`match_term`) | 6 | 38 | 45 | 44 | -| `&[Term::Ore]` | 1 (`ord_term_ore`) | 18 | 26 | 45 | 44 | -| `&[Term::Ope]` | 1 (`ord_term`) | 18 | 26 | 45 | 44 | -| `&[Term::Hm, Term::Ore]` | 2 (`eq_term`, `ord_term_ore`) | 18 | 26 | 46 | 44 | -| `&[Term::Hm, Term::Ope]` | 2 (`eq_term`, `ord_term`) | 18 | 26 | 46 | 44 | -| `&[Term::Hm, Term::Ore, Term::Bloom]` | 3 (`eq_term`, `ord_term_ore`, `match_term`) | 24 | 20 | 47 | 44 | - -Six wrappers for `Hm` = `=` and `<>` × three shapes; six for `Bloom` = `@>` and -`<@` × three shapes; eighteen for `Ore` = six operators × three shapes (`Ope` +| none | 0 | 0 | 47 | 47 | 47 | +| `&[Term::Hm]` | 1 (`eq_term`) | 6 | 41 | 48 | 47 | +| `&[Term::Bloom]` | 1 (`match_term`) | 3 | 44 | 48 | 47 | +| `&[Term::Ore]` | 1 (`ord_term_ore`) | 18 | 29 | 48 | 47 | +| `&[Term::Ope]` | 1 (`ord_term`) | 18 | 29 | 48 | 47 | +| `&[Term::Hm, Term::Ore]` | 2 (`eq_term`, `ord_term_ore`) | 18 | 29 | 49 | 47 | +| `&[Term::Hm, Term::Ope]` | 2 (`eq_term`, `ord_term`) | 18 | 29 | 49 | 47 | +| `&[Term::Hm, Term::Ore, Term::Bloom]` | 3 (`eq_term`, `ord_term_ore`, `match_term`) | 21 | 26 | 50 | 47 | + +Six wrappers for `Hm` = `=` and `<>` × three shapes; three for `Bloom` = `@@` × +three shapes; eighteen for `Ore` = six operators × three shapes (`Ope` mirrors `Ore`'s eighteen — same six operators through `ord_term`). For the multi-term rows the wrapper set is the **deduplicated union**: `[Hm, Ore]` is `{=, <>, <, <=, >, >=}` (Ore's `=`/`<>` collapse onto Hm's — only the *extractor* differs, so the count stays 18, but `=`/`<>` now resolve through `eq_term`, exact HMAC, not ORE); `[Hm, Ope]` (the `text_ord_ope` shape) collapses identically, so `=`/`<>` stay exact HMAC while range operators route through `ord_term`; -`[Hm, Ore, Bloom]` adds `@>`/`<@` for 24. The extra extractor -functions are the only thing that grows `Functions` past 45 — the operator total -is always 44. +`[Hm, Ore, Bloom]` adds `@@` for 21. The extra extractor +functions are the only thing that grows `Functions` past 47 — the operator total +is always 47. **Untyped-literal resolver edge.** PostgreSQL's operator resolver still prefers the built-in `jsonb` operator for untyped string literals in forms such as @@ -770,14 +772,14 @@ edits: `DOMAIN` argument in the `eql_v3` schema. New scalar types need no edit. - **`tasks/test/splinter.sh`** — name-based allowlist. The converged wrapper / extractor names (`eq`, `neq`, `lt`, `lte`, `gt`, `gte`, `eq_term`, `ord_term_ore`, - `ord_term`, the `Bloom` term's `match_term` extractor and its `contains` / - `contained_by` containment wrappers) plus the generated `min` / `max` + `ord_term`, the `Bloom` term's `match_term` extractor and its `matches` + fuzzy-match wrapper) plus the generated `min` / `max` aggregates are covered by `eql_v3`-schema entries, and the SEM `hmac_256` / `ore_block_256` / `bloom_filter` / `ope_cllw` constructors and comparators by `eql_v3_internal`-schema entries. A new scalar type inherits coverage; **a new term needs splinter entries for each new name it introduces — both its extractor and its comparison wrappers** (adding `Bloom` required - `match_term`, `contains`, `contained_by`, and the SEM `bloom_filter`; adding + `match_term`, `matches`, and the SEM `bloom_filter`; adding `Ope` required `ord_term` and the SEM `ope_cllw`). --- @@ -956,10 +958,10 @@ lexicographic `min`/`max` pivots instead of `::MIN`/`::MAX` and a real median lexicographic text has no numeric origin, so it does not get the signed-only sign-boundary test, and the empty string is deliberately not a fixture (`""` encrypts to an empty ORE term; issue #262). `text` is also the first type to add -a new index `Term` (`Bloom`) — giving it a `match` capability (`@>`/`<@` -bloom-filter containment on the `public.eql_v3_text_match` domain) on top of equality +a new index `Term` (`Bloom`) — giving it a `match` capability (`@@` +bloom-filter fuzzy match on the `public.eql_v3_text_match` domain) on top of equality (`Hm`) and ordering (`Ore`). Match is deliberately **not** SQL `LIKE`: it is -probabilistic ngram-bloom containment, exposed only on `text_match`, and never +probabilistic ngram-bloom matching, exposed only on `text_match`, and never backs equality. `jsonb` is a **mixed** family. Its **searchable** SteVec surface remains out of diff --git a/docs/reference/catalog-driven-architecture.md b/docs/reference/catalog-driven-architecture.md index 12615ae75..da9114ed1 100644 --- a/docs/reference/catalog-driven-architecture.md +++ b/docs/reference/catalog-driven-architecture.md @@ -139,7 +139,7 @@ A `Term` answers every question the generators need, via exhaustive `impl` metho | `ctor()` | `hmac_256` | `ore_block_256` | `bloom_filter` | `ope_cllw` | | `binding_newtype()` | `Hmac256` | `OreBlock256` | `BloomFilter` | `OpeCllw` | | `role()` | `Eq` | `Ord` | `Match` | `Ord` | -| `operators()` | `= <>` | `= <> < <= > >=` | `@> <@` | `= <> < <= > >=` | +| `operators()` | `= <>` | `= <> < <= > >=` | `@@` | `= <> < <= > >=` | | `provides_ordering()` | `false` | `true` | `false` | `true` | `Ope` is the CLLW-OPE term: a hex-encoded ciphertext that is natively `bytea`-sortable after diff --git a/docs/reference/database-indexes.md b/docs/reference/database-indexes.md index 58ccf80f5..20153610e 100644 --- a/docs/reference/database-indexes.md +++ b/docs/reference/database-indexes.md @@ -31,7 +31,7 @@ CREATE INDEX users_email_eq CREATE INDEX events_at_ord ON events USING btree (eql_v3.ord_term(encrypted_at)); --- Text match (bloom-filter containment — GIN on the match_term extractor) — public.eql_v3_text_match / text_search +-- Text match (bloom-filter fuzzy match `@@` — GIN on the match_term extractor) — public.eql_v3_text_match / text_search CREATE INDEX users_name_match ON users USING gin (eql_v3.match_term(encrypted_name)); @@ -52,7 +52,7 @@ Create indexes on encrypted columns when: - The table has a significant number of rows (typically > 1000). - You frequently query the column by the matching operator. -- The column is typed as a variant that carries the required term (`_eq` for equality, `_ord` for range/ordering, `text_match` for containment). +- The column is typed as a variant that carries the required term (`_eq` for equality, `_ord` for range/ordering, `text_match` for bloom fuzzy match `@@`). --- @@ -80,7 +80,7 @@ Capability travels in the payload, chosen by the encryption client and reflected - **Equality** needs an `hm` (hmac_256) term — `public._eq`, `public._ord`, `public.eql_v3_text_search`, or `public.eql_v3_text_search_ore`. - **Range / ordering** needs an ordering term — `op` (ope_cllw) on `public._ord` / `_ord_ope` / `public.eql_v3_text_search`, or `ob` (ore_block_256) on `public._ord_ore` / `public.eql_v3_text_search_ore`. -- **Text containment** needs a `bf` (bloom_filter) term — `public.eql_v3_text_match`, `public.eql_v3_text_search`, or `public.eql_v3_text_search_ore`. +- **Text match** (`@@`) needs a `bf` (bloom_filter) term — `public.eql_v3_text_match`, `public.eql_v3_text_search`, or `public.eql_v3_text_search_ore`. A value with only a bloom term will not drive an equality index, and vice versa. diff --git a/docs/reference/eql-functions.md b/docs/reference/eql-functions.md index b1c5f55b5..620490629 100644 --- a/docs/reference/eql-functions.md +++ b/docs/reference/eql-functions.md @@ -41,15 +41,16 @@ SELECT * FROM events WHERE encrypted_at >= $1::public.eql_v3_timestamp_ord; SELECT * FROM events ORDER BY eql_v3.ord_term(encrypted_at) DESC; ``` -### Text match — `@>` `<@` +### Text match — `@@` -On `public.eql_v3_text_match` / `public.eql_v3_text_search` (carry a `bf` bloom term). This is **probabilistic ngram-bloom containment**, not SQL `LIKE` and not JSONB containment: +On `public.eql_v3_text_match` / `public.eql_v3_text_search` / +`public.eql_v3_text_search_ore` (carry a `bf` bloom term). This is **probabilistic ngram-bloom matching** (`eql_v3.matches`), not SQL `LIKE`, not JSONB containment, and not the containment operators — `@>` / `<@` **raise** on these domains (CIP-3517): ```sql -SELECT * FROM docs WHERE encrypted_content @> $1::public.eql_v3_text_match; +SELECT * FROM docs WHERE encrypted_content @@ $1::public.eql_v3_text_match; ``` -`LIKE` / `ILIKE` (`~~` / `~~*`) are **not** part of the `eql_v3` surface — use `@>`. +`LIKE` / `ILIKE` (`~~` / `~~*`) are **not** part of the `eql_v3` surface — use `@@`. ### JSON containment / path — `public.eql_v3_json_search` @@ -68,10 +69,11 @@ eql_v3.lt(a, b) -- < (on _ord / _ord_ore / text_search) eql_v3.lte(a, b) -- <= eql_v3.gt(a, b) -- > eql_v3.gte(a, b) -- >= -eql_v3.contains(a, b) -- @> (on text_match / text_search / public.eql_v3_json_search) -eql_v3.contained_by(a, b) -- <@ +eql_v3.matches(a, b) -- @@ (bloom fuzzy match, on text_match / text_search / text_search_ore) ``` +JSON document containment has its own function forms (`eql_v3.jsonb_contains` / `jsonb_contained_by` / `ste_vec_contains`) — see [EQL with JSON and JSONB](./json-support.md). + **Example:** ```sql @@ -79,7 +81,7 @@ SELECT * FROM users WHERE eql_v3.eq(encrypted_email, $1::public.eql_v3_text_eq); SELECT * FROM events WHERE eql_v3.lt(encrypted_at, $1::public.eql_v3_timestamp_ord); ``` -There are no `like` / `ilike` function forms — text matching is `eql_v3.contains` (`@>`) on a `text_match` value. +There are no `like` / `ilike` function forms — text matching is `eql_v3.matches` (`@@`) on a `text_match` value. --- diff --git a/docs/reference/permissions.md b/docs/reference/permissions.md index 9fa1d9cb9..147e88d5d 100644 --- a/docs/reference/permissions.md +++ b/docs/reference/permissions.md @@ -108,7 +108,7 @@ in `eql_v3`**: | `=` | `eql_v3.eq(a, b)` | | `<>` | `eql_v3.neq(a, b)` | | `<` `<=` `>` `>=` | `eql_v3.lt` / `lte` / `gt` / `gte(a, b)` | -| `@>` `<@` (text match) | `eql_v3.contains` / `contained_by(a, b)` | +| `@@` (text match) | `eql_v3.matches(a, b)` | | `@>` `<@` (jsonb documents) | `eql_v3.jsonb_contains` / `jsonb_contained_by(a, b)`, and the typed `eql_v3.ste_vec_contains` | | `MIN` / `MAX` | `eql_v3.min` / `eql_v3.max` aggregates | diff --git a/docs/reference/sql-support.md b/docs/reference/sql-support.md index 86db39771..773bbb885 100644 --- a/docs/reference/sql-support.md +++ b/docs/reference/sql-support.md @@ -21,7 +21,7 @@ Each scalar type `` is a family of `jsonb`-backed domains in `public`. The ca Every scalar generates a storage-only variant plus the query variants its capabilities allow: -| Domain variant | Index term carried | Extractor (for indexing) | `=` `<>` | `<` `<=` `>` `>=` | `MIN` / `MAX` | `@>` `<@` | +| Domain variant | Index term carried | Extractor (for indexing) | `=` `<>` | `<` `<=` `>` `>=` | `MIN` / `MAX` | `@@` | | ----------------------------- | ------------------------- | ------------------------ | :------: | :---------------: | :-----------: | :-------: | | `public.` | none (storage only) | — | ❌ | ❌ | ❌ | ❌ | | `public._eq` | `hm` (hmac_256) | `eql_v3.eq_term(col)` | ✅ | ❌ | ❌ | ❌ | @@ -31,7 +31,7 @@ Every scalar generates a storage-only variant plus the query variants its capabi | `public.eql_v3_text_search` | `hm` + `op` + `bf` | all three extractors | ✅ | ✅ | ✅ | ✅\* | | `public.eql_v3_text_search_ore` | `hm` + `ob` + `bf` | all three extractors | ✅ | ✅ | ✅ | ✅\* | -\* On `text_match` / `text_search` / `text_search_ore`, `@>` / `<@` are **bloom-filter token containment** (probabilistic ngram match), **not** JSONB containment and **not** SQL `LIKE`. See [Indexing](#indexing). +\* On `text_match` / `text_search` / `text_search_ore`, `@@` (`eql_v3.matches`) is **bloom-filter token matching** (probabilistic ngram match), **not** containment and **not** SQL `LIKE`. The containment operators `@>` / `<@` **raise** on these domains (CIP-3517). See [Indexing](#indexing). Notes: @@ -42,7 +42,7 @@ Notes: - `text_ord` accepts the empty string (its `op` term is well-formed and sorts first). `text_ord_ore` **rejects** it: encrypting `""` yields an empty ORE term (`ob: []`) that the domain CHECK refuses. - `=` / `<>` is the only searchable surface for `_eq`. On `_ord` variants the equality operators are available too (alongside the ordered ones). - `boolean` is **storage-only** by design — a two-value column has too little cardinality for any searchable index to be safe, so it ships only `public.eql_v3_boolean` (no `_eq` / `_ord`). -- `LIKE` / `ILIKE` (`~~` / `~~*`) and the native JSONB operators are **blocked on every scalar domain variant** — they are meaningless on a scalar payload. Text matching is the bloom-filter `@>` on `text_match`, not `LIKE`. +- `LIKE` / `ILIKE` (`~~` / `~~*`) and the native JSONB operators are **blocked on every scalar domain variant** — they are meaningless on a scalar payload. Text matching is the bloom-filter `@@` (`eql_v3.matches`) on `text_match`, not `LIKE`. - `MIN` / `MAX` are exposed only on the ordered variants, as `eql_v3.min(public._ord)` / `eql_v3.max(...)` (and likewise on `_ord_ope` / `_ord_ore`) — see [EQL Functions Reference](./eql-functions.md#eql_v3min--eql_v3max-per-domain). --- @@ -51,19 +51,20 @@ Notes: A ✅ means the operator resolves on a column typed as that domain variant. A ❌ means the operator is blocked (it raises) for that variant. -| SQL operator | Meaning | `public.` | `_eq` | `_ord` / `_ord_ore` / `_ord_ope` | `text_match` | `text_search` | -| ------------------------- | ------------------------------ | :----------: | :---: | :-----------------: | :----------: | :-----------: | -| `=` | Equality | ❌ | ✅ | ✅ | ❌ | ✅ | -| `<>` / `!=` | Inequality | ❌ | ✅ | ✅ | ❌ | ✅ | -| `<` `<=` `>` `>=` | Ordered comparison | ❌ | ❌ | ✅ | ❌ | ✅ | -| `@>` / `<@` | Bloom-filter token containment | ❌ | ❌ | ❌ | ✅ | ✅ | -| `LIKE` `ILIKE` (`~~`/`~~*`) | SQL pattern match | ❌ | ❌ | ❌ | ❌ | ❌ | -| `IS NULL` / `IS NOT NULL` | Null check | ✅ | ✅ | ✅ | ✅ | ✅ | +| SQL operator | Meaning | `public.` | `_eq` | `_ord` / `_ord_ore` / `_ord_ope` | `text_match` | `text_search` | `text_search_ore` | +| ------------------------- | ------------------------------ | :----------: | :---: | :-----------------: | :----------: | :-----------: | :---------------: | +| `=` | Equality | ❌ | ✅ | ✅ | ❌ | ✅ | ✅ | +| `<>` / `!=` | Inequality | ❌ | ✅ | ✅ | ❌ | ✅ | ✅ | +| `<` `<=` `>` `>=` | Ordered comparison | ❌ | ❌ | ✅ | ❌ | ✅ | ✅ | +| `@@` | Bloom-filter token match | ❌ | ❌ | ❌ | ✅ | ✅ | ✅ | +| `@>` / `<@` | Containment — **raises** (use `@@`) | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ | +| `LIKE` `ILIKE` (`~~`/`~~*`) | SQL pattern match | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ | +| `IS NULL` / `IS NOT NULL` | Null check | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | Notes: - A SQL `NULL` column value is not encrypted, so `IS NULL` / `IS NOT NULL` always work regardless of variant. -- `@>` / `<@` on `text_match` / `text_search` test whether the encrypted text **contains** the (encrypted) search terms via the bloom filter. This replaces the old `LIKE`/`ILIKE`-on-`match`-index recipe: there is no `LIKE` on encrypted text — use `@>`. +- `@@` on `text_match` / `text_search` / `text_search_ore` tests whether the encrypted text **matches** the (encrypted) search terms via the bloom filter (n-gram token match, not containment; `@>` / `<@` raise here — CIP-3517). This replaces the old `LIKE`/`ILIKE`-on-`match`-index recipe: there is no `LIKE` on encrypted text — use `@@`. --- @@ -73,13 +74,14 @@ This matrix covers higher-level SQL constructs. As above, ✅ requires the colum | SQL feature | Notes | Required variant | | ------------------------------------ | -------------------------------------------------------------------------------------- | ---------------- | -| `WHERE col = …` / `<>` | | `_eq`, `_ord`, `text_search` | -| `WHERE col <` / `<=` / `>` / `>=` | | `_ord`, `text_search` | -| `WHERE col BETWEEN … AND …` | desugars to `>=` and `<=` | `_ord`, `text_search` | -| `WHERE col @> …` | bloom-filter token containment (text), or document containment (`public.eql_v3_json_search`) | `text_match`, `text_search`, `public.eql_v3_json_search` | -| `WHERE col IN (…)` | desugars to `=` | `_eq`, `_ord`, `text_search` | -| `ORDER BY col` | meaningful only with an ordering term | `_ord`, `text_search` | -| `GROUP BY col` / `DISTINCT` | needs an equality term | `_eq`, `_ord`, `text_search` | +| `WHERE col = …` / `<>` | | `_eq`, `_ord`, `text_search`, `text_search_ore` | +| `WHERE col <` / `<=` / `>` / `>=` | | `_ord`, `text_search`, `text_search_ore` | +| `WHERE col BETWEEN … AND …` | desugars to `>=` and `<=` | `_ord`, `text_search`, `text_search_ore` | +| `WHERE col @@ …` | bloom-filter token match (text) | `text_match`, `text_search`, `text_search_ore` | +| `WHERE col @> …` | document containment (`public.eql_v3_json_search` only; raises on text match) | `public.eql_v3_json_search` | +| `WHERE col IN (…)` | desugars to `=` | `_eq`, `_ord`, `text_search`, `text_search_ore` | +| `ORDER BY col` | meaningful only with an ordering term | `_ord`, `text_search`, `text_search_ore` | +| `GROUP BY col` / `DISTINCT` | needs an equality term | `_eq`, `_ord`, `text_search`, `text_search_ore` | | `MIN(col)` / `MAX(col)` | `eql_v3.min(public._ord)` / `max` — type the column as `_ord` or cast at the call site (`eql_v3.min(col::public.eql_v3_integer_ord)`) | `_ord` | | `COUNT(col)` / `COUNT(DISTINCT col)` | plain `COUNT(col)` needs no term; `DISTINCT` needs an equality term | any / `_eq` for `DISTINCT` | | `JOIN … ON lhs.col = rhs.col` | both sides must share the same keyset and a matching variant | `_eq`, `_ord`, `text_search` | @@ -104,7 +106,7 @@ CREATE INDEX users_email_eq ON users USING hash (eql_v3.eq_term(encrypted_email) -- Ordering / range (btree index on ord_term; use ord_term_ore for an _ord_ore column) CREATE INDEX events_at_ord ON events USING btree (eql_v3.ord_term(encrypted_at)); --- Text match (bloom containment — GIN on match_term) +-- Text match (bloom fuzzy match — GIN on match_term) CREATE INDEX users_name_match ON users USING gin (eql_v3.match_term(encrypted_name)); ``` diff --git a/docs/upgrading/v3.0.md b/docs/upgrading/v3.0.md index 839e98cf3..4c90f651f 100644 --- a/docs/upgrading/v3.0.md +++ b/docs/upgrading/v3.0.md @@ -12,8 +12,9 @@ release is prepared. 3. **Non-superuser installs disable the ORE-backed domains** ([U-003](#u-003-non-superuser-installs-disable-the-ore-backed-domains)). When the installer role cannot create the ORE operator class (cloud-hosted Supabase, most managed Postgres), the `_ord_ore` / `text_search_ore` domains and their query twins now raise `feature_not_supported` on first use instead of silently degrading to seq scans. Use `_ord` (indexed OPE ordering), `_eq`, and `text_match` on those platforms. Superuser installs are unchanged. 4. **SteVec (encrypted JSONB) ordering is CLLW-OPE: sv entries carry `hm` XOR `op`, not `hm` XOR `oc`** ([U-004](#u-004-stevec-ordering-terms-are-cllw-ope-op)). The `eql_v3_internal.ore_cllw` composite type, its custom comparator, operators, and superuser-only btree operator class are removed; entry ordering extracts `eql_v3.ord_term(entry)` — a bytea domain that orders under the DEFAULT btree opclass. `oc`-bearing documents are rejected by the v3 domain CHECKs and must be re-encrypted with an OPE-mode client. 5. **The `_ord` domains are backed by CLLW-OPE, not block-ORE** ([U-005](#u-005-_ord-domains-are-backed-by-cllw-ope)). `public._ord` and `public.eql_v3_text_ord` now require the `op` term. The extractor keeps its name — `eql_v3.ord_term(col)` — but now returns `eql_v3_internal.ope_cllw`, so ordered functional indexes no longer need a superuser-created operator class. The block-ORE surface moves behind the qualified `eql_v3.ord_term_ore(col)` on `public._ord_ore`. Two behaviour changes ride along: `text_ord` now accepts the empty string, and `real`/`double` `_ord` columns now distinguish `-0.0` from `+0.0`. -6. **`public.eql_v3_text_search` is backed by CLLW-OPE too, and `public.eql_v3_text_search_ore` is new** ([U-006](#u-006-text_search-is-backed-by-cllw-ope)). The combined search domain now requires `hm` + `op` + `bf` and orders via `eql_v3.ord_term(col)`; equality (`hm`) and bloom containment (`bf`) are unchanged. The block-ORE shape (`hm` + `ob` + `bf`) lives on the new `public.eql_v3_text_search_ore`. `text_search` now accepts the empty string. +6. **`public.eql_v3_text_search` is backed by CLLW-OPE too, and `public.eql_v3_text_search_ore` is new** ([U-006](#u-006-text_search-is-backed-by-cllw-ope)). The combined search domain now requires `hm` + `op` + `bf` and orders via `eql_v3.ord_term(col)`; equality (`hm`) and bloom fuzzy match (`bf`) are unchanged. The block-ORE shape (`hm` + `ob` + `bf`) lives on the new `public.eql_v3_text_search_ore`. `text_search` now accepts the empty string. 7. **The encrypted-JSON domains are renamed, and `public.eql_v3_json` is now storage-only** ([U-007](#u-007-the-encrypted-json-domains-are-renamed-and-publiceql_v3_json-is-now-storage-only)). The searchable SteVec document `public.eql_v3_json` → `public.eql_v3_json_search`, `public.eql_v3_jsonb_entry` → `public.eql_v3_json_entry`, `eql_v3.query_jsonb` → `eql_v3.query_json`; the bare `public.eql_v3_json` is now a new ciphertext-only storage-only domain. Only affects 3.0.0 pre-release adopters. +8. **Text bloom fuzzy match is `@@` / `eql_v3.matches`, not `@>` / `eql_v3.contains`** ([U-008](#u-008-text-bloom-fuzzy-match-is-renamed-to--eql_v3matches)). On `public.eql_v3_text_match` / `text_search` / `text_search_ore` the fuzzy match is now the single directional operator `@@` (backed by `eql_v3.matches`); `@>` / `<@` (and `eql_v3.contains` / `contained_by`) now **raise** on these domains. It is n-gram token matching, not containment. The GIN index recipe is unchanged. Genuine JSON containment keeps `@>` / `<@`. ## Compatibility @@ -36,6 +37,8 @@ release is prepared. | SteVec sv-entry term keys | **Changed.** `hm` XOR `op` (CLLW-OPE); `oc` (CLLW-ORE) is rejected — see U-004. | | Encrypted-JSON domains (`public.eql_v3_json` searchable, `public.eql_v3_jsonb_entry` — 3.0.0 pre-releases only) | **Renamed.** Searchable document → `public.eql_v3_json_search`, entry → `public.eql_v3_json_entry`; the bare `public.eql_v3_json` is now a new storage-only domain — see U-007. | | `eql_v3.ore_cllw(entry)` / `eql_v3.has_ore_cllw(entry)` / `eql_v3_internal.ore_cllw` (+ comparator, operators, opclass) | **Removed.** Entry ordering is `eql_v3.ord_term(entry)` — see U-004. | +| 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. | +| JSON containment (`public.eql_v3_json_search` `@>` / `<@`, `eql_v3.ste_vec_contains`) | **Unchanged.** Genuine containment keeps the containment vocabulary — see U-008. | | Legacy `eql_v2` wire documentation (`docs/reference/schema/eql-payload-v2.*.schema.json`) | **Unchanged.** Stays `v: 2`. | ## Upgrade notes @@ -171,7 +174,7 @@ support regardless of which role queries later. `_ord_ope` twin) instead of `_ord_ore`, and index with `CREATE INDEX ... USING btree (eql_v3.ord_term(col))`. The combined `public.eql_v3_text_search` domain is CLLW-OPE-backed (see U-006) and is **not** -poisoned, so equality, ordering, and bloom containment all work on it here — +poisoned, so equality, ordering, and bloom fuzzy match all work on it here — only its block-ORE sibling `public.eql_v3_text_search_ore` is disabled. Nothing needs to be split into `text_eq` + `text_match` + `text_ord` columns. @@ -416,9 +419,9 @@ The block-ORE surface is still installed, so no EQL downgrade is required. ### U-006: `text_search` is backed by CLLW-OPE **What changed.** `public.eql_v3_text_search` — the combined domain carrying equality, -ordering, and bloom containment in one type — swapped its **ordering** term from +ordering, and bloom fuzzy match in one type — swapped its **ordering** term from block-ORE to CLLW-OPE, exactly as `_ord` did in U-005. Its equality (`hm`) and -containment (`bf`) terms are untouched. The block-ORE shape is preserved under a +match (`bf`) terms are untouched. The block-ORE shape is preserved under a new name, `public.eql_v3_text_search_ore`. | | `public.eql_v3_text_search` (changed) | `public.eql_v3_text_search_ore` (new) | @@ -426,12 +429,13 @@ new name, `public.eql_v3_text_search_ore`. | CHECK requires | `hm` + `op` + `bf` | `hm` + `ob` + `bf` | | ordering extractor | `eql_v3.ord_term(col)` → `eql_v3_internal.ope_cllw` | `eql_v3.ord_term_ore(col)` → `eql_v3_internal.ore_block_256` | | equality extractor | `eql_v3.eq_term(col)` | `eql_v3.eq_term(col)` | -| containment extractor | `eql_v3.match_term(col)` | `eql_v3.match_term(col)` | +| match extractor | `eql_v3.match_term(col)` | `eql_v3.match_term(col)` | | empty string | **accepted**, sorts first | rejected (`check_violation`) | The operator surface of the two domains is identical (`=` `<>` `<` `<=` `>` `>=` -`@>` `<@`). Equality still routes through `hm` on both — text ordering terms are -not equality-lossless — and containment still routes through `bf`. +`@@`). Equality still routes through `hm` on both — text ordering terms are +not equality-lossless — and fuzzy match still routes through `bf` (via the `@@` +operator / `eql_v3.matches`, renamed from `@>`/`contains` in [U-008](#u-008-text-bloom-fuzzy-match-is-renamed-to--eql_v3matches)). **Why.** The same reason as U-005, and it is not about operator capability. `text_search` ordered through block-ORE, whose btree operator class is @@ -462,7 +466,9 @@ emitting `ob` into one, or an index / extractor-form `ORDER BY` written against no longer exists. On an OPE `text_search` column the ordering extractor is `eql_v3.ord_term(col)`; on `text_search_ore` it stays `eql_v3.ord_term_ore(col)`. Bare-form predicates (`WHERE col < $1`) and bare `ORDER BY col` need no change. - Equality and `@>` / `<@` index recipes are unaffected on both domains. + Equality and `@@` (fuzzy match) index recipes are unaffected on both domains + (the match operator/function was renamed `@>`/`contains` → `@@`/`matches` — see + [U-008](#u-008-text-bloom-fuzzy-match-is-renamed-to--eql_v3matches)). 3. **Rebuild ordered indexes on `text_search`.** The DDL text is unchanged, but the expression now returns a different type over a different payload term. @@ -482,7 +488,7 @@ SELECT to_regprocedure('eql_v3.ord_term(public.eql_v3_text_search)') IS SELECT to_regprocedure('eql_v3.ord_term_ore(public.eql_v3_text_search)') IS NULL; -- t -- the block-ORE sibling exists and keeps the ORE extractor. SELECT to_regprocedure('eql_v3.ord_term_ore(public.eql_v3_text_search_ore)') IS NOT NULL; -- t --- both still support equality and bloom containment. +-- both still support equality and bloom fuzzy match. SELECT to_regprocedure('eql_v3.match_term(public.eql_v3_text_search)') IS NOT NULL; -- t SELECT to_regprocedure('eql_v3.match_term(public.eql_v3_text_search_ore)') IS NOT NULL; -- t @@ -554,3 +560,61 @@ SELECT '{"v":"3","i":{},"sv":[{"s":"a","hm":"h"}]}'::jsonb::public.eql_v3_json; **Rollback.** None required beyond retyping columns back — this is a rename of a pre-release surface; no envelope or term-key change rides along. + +### U-008: text bloom fuzzy match is renamed to `@@` / `eql_v3.matches` + +**What changed.** On the text bloom-match domains — `public.eql_v3_text_match`, +`public.eql_v3_text_search`, `public.eql_v3_text_search_ore` — the fuzzy match was +previously spelled with the containment operators `@>` / `<@`, backed by the public +wrappers `eql_v3.contains` / `eql_v3.contained_by`. It is now a single directional +operator `@@`, backed by `eql_v3.matches`. The reverse `contained_by` direction is +dropped, and `@>` / `<@` now **raise** `operator ... is not supported` on these +domains (they are generated as blockers). + +| | before (3.0.0 pre-release) | now | +| --- | --- | --- | +| operator | `col @> $1` (contains), `col <@ $1` | `col @@ $1` (matches) | +| function | `eql_v3.contains(col, $1)`, `eql_v3.contained_by(col, $1)` | `eql_v3.matches(col, $1)` | +| `@>` / `<@` on the domain | supported (were the match operators) | **raise** ("not supported") | +| GIN index recipe | `GIN (eql_v3.match_term(col))` | **unchanged** | + +**Why.** The operation is **not containment**. `col @@ needle` reduces to +`eql_v3.match_term(col) @> eql_v3.match_term(needle)` — array containment over two +bloom filters built from the downcased 3-gram token set. That is a probabilistic, +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 +SQL-layer counterpart of the SDK's `contains()` → `matches()` rename. + +**Who is affected.** Anyone with a query, view, or SDK/adapter that emits +`eql_v3.contains(col, …)` / `eql_v3.contained_by(col, …)` or the `@>` / `<@` +operators against a `text_match` / `text_search` / `text_search_ore` column. + +**What to do.** Repoint match predicates from `@>` / `contains` to `@@` / `matches`. +The functional GIN index needs no change — `col @@ $1` inlines through `match_term` +to the same array-containment the index supports: + +```sql +-- before: +SELECT * FROM t WHERE name @> $1::public.eql_v3_text_match; +SELECT * FROM t WHERE eql_v3.contains(name, $1::public.eql_v3_text_match); + +-- now: +SELECT * FROM t WHERE name @@ $1::public.eql_v3_text_match; +SELECT * FROM t WHERE eql_v3.matches(name, $1::public.eql_v3_text_match); +``` + +Coordinate with the client: an SDK still emitting `eql_v3.contains(` for text match +must switch to `eql_v3.matches(` in the same release, since `contains` is no longer +a callable public function on these domains. + +**Verification.** `\df eql_v3.matches` lists the wrapper; `col @@ $1` engages the +`eql_v3.match_term(col)` GIN index (`EXPLAIN` shows a Bitmap/Index Scan); `col @> $1` +now raises `operator ... is not supported`. Genuine JSON containment is unchanged: +`WHERE doc @> $1::eql_v3.query_json` still works. + +**Rollback.** None beyond reverting queries from `@@` / `matches` back to the previous +`@>` / `contains` forms — there is no envelope, term-key, or index change; only the +operator/function name moved. diff --git a/packages/eql/sql/cipherstash-encrypt.sql b/packages/eql/sql/cipherstash-encrypt.sql index f3ecc01d6..286ae1050 100644 --- a/packages/eql/sql/cipherstash-encrypt.sql +++ b/packages/eql/sql/cipherstash-encrypt.sql @@ -77,6 +77,53 @@ AS $$ SELECT ARRAY['eql_v3', 'eql_v3_internal']::name[] $$; +--! @file v3/sem/ope_cllw/types.sql +--! @brief CLLW OPE index term type for scalar range queries (eql_v3 SEM) +--! +--! Domain type representing a CLLW (Copyless Logarithmic Width) +--! Order-Preserving Encryption term. The ciphertext is stored hex-encoded in +--! the `op` field of encrypted scalar payloads (the `_ord_ope` domains); the +--! domain carries the hex-decoded bytes. +--! +--! A DOMAIN over bytea, not a composite: the OPE ciphertext is +--! order-preserving under plain byte comparison, so the domain inherits +--! bytea's native comparison operators and DEFAULT btree operator class +--! outright — no hand-written operators, comparator, or operator class (the +--! same pattern as eql_v3_internal.hmac_256 over text). That keeps the whole +--! comparison chain inlinable, so a functional btree index on +--! `eql_v3.ord_term(col)` engages structurally for the `_ord` / `_ord_ope` +--! domains' comparison operators. Contrast eql_v3_internal.ore_cllw (`oc`), the SteVec +--! CLLW-*ORE* composite compared by a custom per-byte protocol. +--! +--! @note Transient type used only during query execution. +--! @see eql_v3_internal.ope_cllw +CREATE DOMAIN eql_v3_internal.ope_cllw AS bytea; + +--! @file v3/sem/ore_block_256/types.sql +--! @brief ORE block index-term types (eql_v3 SEM). +--! +--! Self-contained eql_v3 copies of the Order-Revealing Encryption block types +--! (design D1/D3). The eql_v2 originals are unchanged. + +--! @brief ORE block term type for Order-Revealing Encryption +--! +--! Composite type representing a single ORE block term. Stores encrypted data +--! as bytea that enables range comparisons without decryption. +CREATE TYPE eql_v3_internal.ore_block_256_term AS ( + bytes bytea +); + + +--! @brief ORE block index term type for range queries +--! +--! Composite type containing an array of ORE block terms. The array is stored +--! in the 'ob' field of encrypted data payloads. +--! +--! @note Transient type used only during query execution. +CREATE TYPE eql_v3_internal.ore_block_256 AS ( + terms eql_v3_internal.ore_block_256_term[] +); + --! @file v3/crypto.sql --! @brief PostgreSQL pgcrypto extension enablement (eql_v3 fork) --! @@ -185,30 +232,164 @@ $$ LANGUAGE plpgsql; COMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(jsonb) IS 'eql-inline-critical: per-encrypted-value ORE opclass-path helper; must stay unpinned (SET search_path adds per-call overhead)'; ---! @file v3/sem/ore_block_256/types.sql ---! @brief ORE block index-term types (eql_v3 SEM). +--! @file v3/sem/hmac_256/types.sql +--! @brief HMAC-SHA256 index term type (eql_v3 SEM) --! ---! Self-contained eql_v3 copies of the Order-Revealing Encryption block types ---! (design D1/D3). The eql_v2 originals are unchanged. +--! Domain type representing HMAC-SHA256 hash values. Used for exact-match +--! encrypted searches. The hash is stored in the 'hm' field of encrypted data +--! payloads. Self-contained eql_v3 copy (design D1/D3); the eql_v2 original is +--! unchanged. +--! +--! @note Transient type used only during query execution. +CREATE DOMAIN eql_v3_internal.hmac_256 AS text; ---! @brief ORE block term type for Order-Revealing Encryption +--! @file v3/sem/bloom_filter/types.sql +--! @brief Self-contained eql_v3 Bloom-filter SEM index-term type. + +--! @brief Bloom-filter index term: a bit array stored as smallint[]. --! ---! Composite type representing a single ORE block term. Stores encrypted data ---! as bytea that enables range comparisons without decryption. -CREATE TYPE eql_v3_internal.ore_block_256_term AS ( - bytes bytea -); +--! Backs the `matches` fuzzy-match capability (the public `@@` operator / +--! `eql_v3.matches`) on the text match/search domains. The filter is read from +--! the `bf` field of an encrypted jsonb payload. The match wrapper body reduces +--! to native `smallint[]` array-containment (`@>`) on this domain — inherited +--! through the base type — so a functional GIN index on `eql_v3.match_term(col)` +--! engages; this type itself needs no custom operators. +--! +--! @note The public operator is `@@` (fuzzy bloom-token matching), NOT the +--! containment operators `@>`/`<@`: the match is a probabilistic, one-sided +--! n-gram token match, not containment (CIP-3517). `@>`/`<@` on the text match +--! domains now raise. Internally the `@@` wrapper still reduces to the base +--! type's `@>` for GIN indexability. +--! @note Self-contained: references no eql_v2 symbol. +CREATE DOMAIN eql_v3_internal.bloom_filter AS smallint[]; +--! @file v3/scalars/functions.sql +--! @brief Shared blocker helper for the eql_v3 encrypted-domain families. +--! +--! Per-domain wrapper functions live in src/v3/scalars//. +--! Blockers in those files delegate to encrypted_domain_unsupported_bool +--! so every domain raises a uniform domain-specific error rather than +--! letting an unsupported operator fall through to native jsonb +--! behaviour. ---! @brief ORE block index term type for range queries +--! @brief Shared blocker helper. Raises 'operator X is not supported +--! for TYPE' so unsupported domain operators surface a clear +--! error rather than fall through to native jsonb behaviour. +--! @param type_name Domain type name (eql_v3.*) +--! @param operator_name Operator symbol (=, <, @>, ->, etc.) +--! @return boolean (never returns; always raises) +CREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_bool(type_name text, operator_name text) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name; +END; +$$ LANGUAGE plpgsql; + +--! @brief Shared blocker helper returning jsonb. Identical to +--! encrypted_domain_unsupported_bool but typed for blockers shadowing +--! native operators whose result is jsonb (#>, -, #-, ||), so composed +--! expressions resolve and the body raises rather than failing earlier +--! with a misleading 'operator does not exist' on a boolean result. +--! @param type_name Domain type name (eql_v3.*) +--! @param operator_name Operator symbol (#>, -, #-, ||, etc.) +--! @return jsonb (never returns; always raises) +CREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_jsonb(type_name text, operator_name text) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name; +END; +$$ LANGUAGE plpgsql; + +--! @brief Shared blocker helper returning text. Identical to +--! encrypted_domain_unsupported_bool but typed for blockers shadowing +--! the native #>> operator whose result is text. +--! @param type_name Domain type name (eql_v3.*) +--! @param operator_name Operator symbol (#>>) +--! @return text (never returns; always raises) +CREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_text(type_name text, operator_name text) +RETURNS text +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name; +END; +$$ LANGUAGE plpgsql; + +--! @file v3/sem/hmac_256/functions.sql +--! @brief HMAC-SHA256 index-term extraction from a jsonb payload (eql_v3 SEM). --! ---! Composite type containing an array of ORE block terms. The array is stored ---! in the 'ob' field of encrypted data payloads. +--! jsonb-only subset of src/hmac_256/functions.sql. The encrypted-column and +--! ste_vec-entry overloads are intentionally omitted — the eql_v3 scalar +--! domains extract from the jsonb payload directly via a cast to the domain. +--! (Doc comments deliberately avoid naming eql_v2 symbols so the +--! self-containment grep stays clean.) + +--! @brief Extract HMAC-SHA256 index term from JSONB payload --! ---! @note Transient type used only during query execution. -CREATE TYPE eql_v3_internal.ore_block_256 AS ( - terms eql_v3_internal.ore_block_256_term[] -); +--! Inlinable single-statement SQL — the planner can fold this into the calling +--! query so functional hash/btree indexes built on `eql_v3_internal.eq_term(col)` +--! (which calls this) engage structurally. +--! +--! @param val jsonb containing encrypted EQL payload +--! @return eql_v3_internal.hmac_256 HMAC-SHA256 hash value, or NULL when `hm` is absent +CREATE FUNCTION eql_v3_internal.hmac_256(val jsonb) + RETURNS eql_v3_internal.hmac_256 + LANGUAGE sql + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT (val ->> 'hm')::eql_v3_internal.hmac_256 +$$; + + +--! @brief Check if JSONB payload contains HMAC-SHA256 index term +--! +--! @param val jsonb containing encrypted EQL payload +--! @return boolean True if 'hm' field is present and non-null +CREATE FUNCTION eql_v3_internal.has_hmac_256(val jsonb) + RETURNS boolean + LANGUAGE sql + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT (val ->> 'hm') IS NOT NULL +$$; + +--! @file v3/sem/ope_cllw/functions.sql +--! @brief CLLW OPE index-term extraction from a jsonb payload (eql_v3 SEM). + +--! @brief Extract CLLW OPE index term from JSONB payload +--! +--! Returns the CLLW OPE ciphertext from the `op` field of an encrypted scalar +--! payload, hex-decoded to the bytea-backed eql_v3_internal.ope_cllw domain. +--! +--! Inlinable single-statement SQL — the body is a strict expression of the +--! argument (`->>` and `decode` are both STRICT), so the planner folds this +--! into the calling query and functional btree indexes built on +--! `eql_v3.ord_term(col)` (which calls this) engage structurally, the +--! same way the hmac_256 equality chain does. +--! +--! **Missing-`op` semantics**: `val ->> 'op'` is NULL when `op` is absent and +--! the strict chain propagates it, so the extractor returns SQL NULL and +--! btree's NULL handling filters those rows from range queries. +--! +--! @param val jsonb containing encrypted EQL payload +--! @return eql_v3_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when `op` is +--! absent +CREATE FUNCTION eql_v3_internal.ope_cllw(val jsonb) + RETURNS eql_v3_internal.ope_cllw + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT decode(val ->> 'op', 'hex')::eql_v3_internal.ope_cllw +$$; + +COMMENT ON FUNCTION eql_v3_internal.ope_cllw(jsonb) IS + 'eql-inline-critical: raw-jsonb CLLW OPE extractor; must stay inlinable (unpinned search_path)'; --! @file v3/sem/ore_block_256/functions.sql --! @brief ORE block construction, extraction, and comparison (eql_v3 SEM). @@ -481,210 +662,6 @@ AS $$ END $$ LANGUAGE plpgsql; ---! @file v3/sem/ope_cllw/types.sql ---! @brief CLLW OPE index term type for scalar range queries (eql_v3 SEM) ---! ---! Domain type representing a CLLW (Copyless Logarithmic Width) ---! Order-Preserving Encryption term. The ciphertext is stored hex-encoded in ---! the `op` field of encrypted scalar payloads (the `_ord_ope` domains); the ---! domain carries the hex-decoded bytes. ---! ---! A DOMAIN over bytea, not a composite: the OPE ciphertext is ---! order-preserving under plain byte comparison, so the domain inherits ---! bytea's native comparison operators and DEFAULT btree operator class ---! outright — no hand-written operators, comparator, or operator class (the ---! same pattern as eql_v3_internal.hmac_256 over text). That keeps the whole ---! comparison chain inlinable, so a functional btree index on ---! `eql_v3.ord_term(col)` engages structurally for the `_ord` / `_ord_ope` ---! domains' comparison operators. Contrast eql_v3_internal.ore_cllw (`oc`), the SteVec ---! CLLW-*ORE* composite compared by a custom per-byte protocol. ---! ---! @note Transient type used only during query execution. ---! @see eql_v3_internal.ope_cllw -CREATE DOMAIN eql_v3_internal.ope_cllw AS bytea; - ---! @file v3/sem/hmac_256/types.sql ---! @brief HMAC-SHA256 index term type (eql_v3 SEM) ---! ---! Domain type representing HMAC-SHA256 hash values. Used for exact-match ---! encrypted searches. The hash is stored in the 'hm' field of encrypted data ---! payloads. Self-contained eql_v3 copy (design D1/D3); the eql_v2 original is ---! unchanged. ---! ---! @note Transient type used only during query execution. -CREATE DOMAIN eql_v3_internal.hmac_256 AS text; - ---! @file v3/sem/bloom_filter/types.sql ---! @brief Self-contained eql_v3 Bloom-filter SEM index-term type. - ---! @brief Bloom-filter index term: a bit array stored as smallint[]. ---! ---! Backs the `match` capability (`@>` / `<@`) on `eql_v3_internal.text_match`. The ---! filter is read from the `bf` field of an encrypted jsonb payload. Native ---! `smallint[]` array-containment (`@>`/`<@`) is inherited through the domain, ---! so this type needs no custom operators. ---! ---! @note Self-contained: references no eql_v2 symbol. -CREATE DOMAIN eql_v3_internal.bloom_filter AS smallint[]; --- AUTOMATICALLY GENERATED FILE. - ---! @file v3/scalars/timestamp/timestamp_types.sql ---! @brief Encrypted-domain types for timestamp. - -DO $$ -BEGIN - --! @brief Encrypted domain public.eql_v3_timestamp. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_timestamp' AND typnamespace = 'public'::regnamespace - ) THEN - CREATE DOMAIN public.eql_v3_timestamp AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN public.eql_v3_timestamp IS 'EQL encrypted timestamp (storage only)'; - - --! @brief Encrypted domain public.eql_v3_timestamp_eq. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_timestamp_eq' AND typnamespace = 'public'::regnamespace - ) THEN - CREATE DOMAIN public.eql_v3_timestamp_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN public.eql_v3_timestamp_eq IS 'EQL encrypted timestamp (equality)'; - - --! @brief Encrypted domain public.eql_v3_timestamp_ord_ore. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_timestamp_ord_ore' AND typnamespace = 'public'::regnamespace - ) THEN - CREATE DOMAIN public.eql_v3_timestamp_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN public.eql_v3_timestamp_ord_ore IS 'EQL encrypted timestamp (equality, ordering)'; - - --! @brief Encrypted domain public.eql_v3_timestamp_ord. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_timestamp_ord' AND typnamespace = 'public'::regnamespace - ) THEN - CREATE DOMAIN public.eql_v3_timestamp_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'op' - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN public.eql_v3_timestamp_ord IS 'EQL encrypted timestamp (equality, ordering)'; - - --! @brief Encrypted domain public.eql_v3_timestamp_ord_ope. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_timestamp_ord_ope' AND typnamespace = 'public'::regnamespace - ) THEN - CREATE DOMAIN public.eql_v3_timestamp_ord_ope AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'op' - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN public.eql_v3_timestamp_ord_ope IS 'EQL encrypted timestamp (equality, ordering)'; -END -$$; - ---! @file v3/scalars/functions.sql ---! @brief Shared blocker helper for the eql_v3 encrypted-domain families. ---! ---! Per-domain wrapper functions live in src/v3/scalars//. ---! Blockers in those files delegate to encrypted_domain_unsupported_bool ---! so every domain raises a uniform domain-specific error rather than ---! letting an unsupported operator fall through to native jsonb ---! behaviour. - ---! @brief Shared blocker helper. Raises 'operator X is not supported ---! for TYPE' so unsupported domain operators surface a clear ---! error rather than fall through to native jsonb behaviour. ---! @param type_name Domain type name (eql_v3.*) ---! @param operator_name Operator symbol (=, <, @>, ->, etc.) ---! @return boolean (never returns; always raises) -CREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_bool(type_name text, operator_name text) -RETURNS boolean -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name; -END; -$$ LANGUAGE plpgsql; - ---! @brief Shared blocker helper returning jsonb. Identical to ---! encrypted_domain_unsupported_bool but typed for blockers shadowing ---! native operators whose result is jsonb (#>, -, #-, ||), so composed ---! expressions resolve and the body raises rather than failing earlier ---! with a misleading 'operator does not exist' on a boolean result. ---! @param type_name Domain type name (eql_v3.*) ---! @param operator_name Operator symbol (#>, -, #-, ||, etc.) ---! @return jsonb (never returns; always raises) -CREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_jsonb(type_name text, operator_name text) -RETURNS jsonb -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name; -END; -$$ LANGUAGE plpgsql; - ---! @brief Shared blocker helper returning text. Identical to ---! encrypted_domain_unsupported_bool but typed for blockers shadowing ---! the native #>> operator whose result is text. ---! @param type_name Domain type name (eql_v3.*) ---! @param operator_name Operator symbol (#>>) ---! @return text (never returns; always raises) -CREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_text(type_name text, operator_name text) -RETURNS text -IMMUTABLE PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name; -END; -$$ LANGUAGE plpgsql; - --! @file v3/sem/ore_block_256/operators.sql --! @brief Comparison operators on eql_v3_internal.ore_block_256. --! @@ -861,88 +838,19 @@ CREATE OPERATOR public.>= ( RESTRICT = scalargesel, JOIN = scalargejoinsel ); - ---! @file v3/sem/ope_cllw/functions.sql ---! @brief CLLW OPE index-term extraction from a jsonb payload (eql_v3 SEM). - ---! @brief Extract CLLW OPE index term from JSONB payload ---! ---! Returns the CLLW OPE ciphertext from the `op` field of an encrypted scalar ---! payload, hex-decoded to the bytea-backed eql_v3_internal.ope_cllw domain. ---! ---! Inlinable single-statement SQL — the body is a strict expression of the ---! argument (`->>` and `decode` are both STRICT), so the planner folds this ---! into the calling query and functional btree indexes built on ---! `eql_v3.ord_term(col)` (which calls this) engage structurally, the ---! same way the hmac_256 equality chain does. ---! ---! **Missing-`op` semantics**: `val ->> 'op'` is NULL when `op` is absent and ---! the strict chain propagates it, so the extractor returns SQL NULL and ---! btree's NULL handling filters those rows from range queries. ---! ---! @param val jsonb containing encrypted EQL payload ---! @return eql_v3_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when `op` is ---! absent -CREATE FUNCTION eql_v3_internal.ope_cllw(val jsonb) - RETURNS eql_v3_internal.ope_cllw - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT decode(val ->> 'op', 'hex')::eql_v3_internal.ope_cllw -$$; - -COMMENT ON FUNCTION eql_v3_internal.ope_cllw(jsonb) IS - 'eql-inline-critical: raw-jsonb CLLW OPE extractor; must stay inlinable (unpinned search_path)'; - ---! @file v3/sem/hmac_256/functions.sql ---! @brief HMAC-SHA256 index-term extraction from a jsonb payload (eql_v3 SEM). ---! ---! jsonb-only subset of src/hmac_256/functions.sql. The encrypted-column and ---! ste_vec-entry overloads are intentionally omitted — the eql_v3 scalar ---! domains extract from the jsonb payload directly via a cast to the domain. ---! (Doc comments deliberately avoid naming eql_v2 symbols so the ---! self-containment grep stays clean.) - ---! @brief Extract HMAC-SHA256 index term from JSONB payload ---! ---! Inlinable single-statement SQL — the planner can fold this into the calling ---! query so functional hash/btree indexes built on `eql_v3_internal.eq_term(col)` ---! (which calls this) engage structurally. ---! ---! @param val jsonb containing encrypted EQL payload ---! @return eql_v3_internal.hmac_256 HMAC-SHA256 hash value, or NULL when `hm` is absent -CREATE FUNCTION eql_v3_internal.hmac_256(val jsonb) - RETURNS eql_v3_internal.hmac_256 - LANGUAGE sql - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT (val ->> 'hm')::eql_v3_internal.hmac_256 -$$; - - ---! @brief Check if JSONB payload contains HMAC-SHA256 index term ---! ---! @param val jsonb containing encrypted EQL payload ---! @return boolean True if 'hm' field is present and non-null -CREATE FUNCTION eql_v3_internal.has_hmac_256(val jsonb) - RETURNS boolean - LANGUAGE sql - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT (val ->> 'hm') IS NOT NULL -$$; -- AUTOMATICALLY GENERATED FILE. ---! @file v3/scalars/text/text_types.sql ---! @brief Encrypted-domain types for text. +--! @file v3/scalars/real/real_types.sql +--! @brief Encrypted-domain types for real. DO $$ BEGIN - --! @brief Encrypted domain public.eql_v3_text. + --! @brief Encrypted domain public.eql_v3_real. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_text' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_real' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_text AS jsonb + CREATE DOMAIN public.eql_v3_real AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -952,14 +860,14 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_text IS 'EQL encrypted text (storage only)'; + COMMENT ON DOMAIN public.eql_v3_real IS 'EQL encrypted real (storage only)'; - --! @brief Encrypted domain public.eql_v3_text_eq. + --! @brief Encrypted domain public.eql_v3_real_eq. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_text_eq' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_real_eq' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_text_eq AS jsonb + CREATE DOMAIN public.eql_v3_real_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -970,198 +878,1023 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_text_eq IS 'EQL encrypted text (equality)'; + COMMENT ON DOMAIN public.eql_v3_real_eq IS 'EQL encrypted real (equality)'; - --! @brief Encrypted domain public.eql_v3_text_match. + --! @brief Encrypted domain public.eql_v3_real_ord_ore. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_text_match' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_real_ord_ore' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_text_match AS jsonb + CREATE DOMAIN public.eql_v3_real_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' - AND VALUE ? 'bf' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 AND VALUE->>'v' = '3' ); END IF; - COMMENT ON DOMAIN public.eql_v3_text_match IS 'EQL encrypted text (containment)'; + COMMENT ON DOMAIN public.eql_v3_real_ord_ore IS 'EQL encrypted real (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_text_ord_ore. + --! @brief Encrypted domain public.eql_v3_real_ord. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_text_ord_ore' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_real_ord' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_text_ord_ore AS jsonb + CREATE DOMAIN public.eql_v3_real_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE ? 'op' AND VALUE->>'v' = '3' ); END IF; - COMMENT ON DOMAIN public.eql_v3_text_ord_ore IS 'EQL encrypted text (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_real_ord IS 'EQL encrypted real (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_text_ord. + --! @brief Encrypted domain public.eql_v3_real_ord_ope. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_text_ord' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_real_ord_ope' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_text_ord AS jsonb + CREATE DOMAIN public.eql_v3_real_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' - AND VALUE ? 'hm' AND VALUE ? 'op' AND VALUE->>'v' = '3' ); END IF; - COMMENT ON DOMAIN public.eql_v3_text_ord IS 'EQL encrypted text (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_real_ord_ope IS 'EQL encrypted real (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. - --! @brief Encrypted domain public.eql_v3_text_ord_ope. +--! @file encrypted_domain/real/real_ord_ore_functions.sql +--! @brief Functions for public.eql_v3_real_ord_ore. + +--! @brief Index extractor for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_real_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) = eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) <> eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) < eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) <= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) > eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) >= eql_v3.ord_term_ore(b) $$; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param selector text +--! @return public.eql_v3_real_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ore, selector text) +RETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param selector integer +--! @return public.eql_v3_real_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ore, selector integer) +RETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a jsonb +--! @param selector public.eql_v3_real_ord_ore +--! @return public.eql_v3_real_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_ord_ore) +RETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a jsonb +--! @param selector public.eql_v3_real_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_real_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b public.eql_v3_real_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_real_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/smallint/smallint_types.sql +--! @brief Encrypted-domain types for smallint. + +DO $$ +BEGIN + --! @brief Encrypted domain public.eql_v3_smallint. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_text_ord_ope' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_smallint' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_text_ord_ope AS jsonb + CREATE DOMAIN public.eql_v3_smallint AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' - AND VALUE ? 'hm' - AND VALUE ? 'op' AND VALUE->>'v' = '3' ); END IF; - COMMENT ON DOMAIN public.eql_v3_text_ord_ope IS 'EQL encrypted text (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_smallint IS 'EQL encrypted smallint (storage only)'; - --! @brief Encrypted domain public.eql_v3_text_search_ore. + --! @brief Encrypted domain public.eql_v3_smallint_eq. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_text_search_ore' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_smallint_eq' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_text_search_ore AS jsonb + CREATE DOMAIN public.eql_v3_smallint_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' AND VALUE ? 'hm' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.eql_v3_smallint_eq IS 'EQL encrypted smallint (equality)'; + + --! @brief Encrypted domain public.eql_v3_smallint_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'eql_v3_smallint_ord_ore' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.eql_v3_smallint_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' AND VALUE ? 'ob' - AND VALUE ? 'bf' AND jsonb_typeof(VALUE -> 'ob') = 'array' AND jsonb_array_length(VALUE -> 'ob') > 0 AND VALUE->>'v' = '3' ); END IF; - COMMENT ON DOMAIN public.eql_v3_text_search_ore IS 'EQL encrypted text (equality, ordering, containment)'; + COMMENT ON DOMAIN public.eql_v3_smallint_ord_ore IS 'EQL encrypted smallint (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_text_search. + --! @brief Encrypted domain public.eql_v3_smallint_ord. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_text_search' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_smallint_ord' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_text_search AS jsonb + CREATE DOMAIN public.eql_v3_smallint_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'op' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.eql_v3_smallint_ord IS 'EQL encrypted smallint (equality, ordering)'; + + --! @brief Encrypted domain public.eql_v3_smallint_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'eql_v3_smallint_ord_ope' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.eql_v3_smallint_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' - AND VALUE ? 'hm' AND VALUE ? 'op' - AND VALUE ? 'bf' AND VALUE->>'v' = '3' ); END IF; - COMMENT ON DOMAIN public.eql_v3_text_search IS 'EQL encrypted text (equality, ordering, containment)'; + COMMENT ON DOMAIN public.eql_v3_smallint_ord_ope IS 'EQL encrypted smallint (equality, ordering)'; END $$; +-- AUTOMATICALLY GENERATED FILE. ---! @file v3/sem/bloom_filter/functions.sql ---! @brief Extractor for the eql_v3 Bloom-filter SEM index term. ---! ---! jsonb-only subset of src/bloom_filter/functions.sql. The encrypted-column ---! overloads are intentionally omitted — the eql_v3 scalar domains extract from ---! the jsonb payload directly via a cast to the domain. (Doc comments ---! deliberately avoid naming eql_v2 symbols so the self-containment grep stays ---! clean.) +--! @file encrypted_domain/smallint/smallint_eq_functions.sql +--! @brief Functions for public.eql_v3_smallint_eq. ---! @brief Test whether a jsonb payload carries a Bloom-filter (`bf`) term. ---! ---! @param val jsonb The encrypted payload. ---! @return boolean True when the `bf` key is present and non-null. ---! ---! @internal Defined for parity with the eql_v3 SEM index-term predicates ---! (`has_hmac_256` / `has_ore_block_256`); it is not currently called by ---! the extractor below, which gates on value-shape inline, nor by the generated ---! domain CHECK, which tests `bf` presence via the envelope-key skeleton. Kept ---! as the canonical presence test for callers that need one. -CREATE FUNCTION eql_v3_internal.has_bloom_filter(val jsonb) - RETURNS boolean - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - BEGIN - RETURN val ? 'bf' AND val ->> 'bf' IS NOT NULL; - END; -$$ LANGUAGE plpgsql; +--! @brief Index extractor for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_smallint_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Extract the Bloom-filter index term from a jsonb payload. ---! ---! Inlinable single-statement SQL — the planner can fold this into the calling ---! query so the functional GIN index built on `eql_v3_internal.match_term(col)` (which ---! calls this) engages structurally. Mirrors `eql_v3_internal.hmac_256(jsonb)`: no RAISE ---! and no pinned `search_path`. Returns NULL when `bf` is absent or present but ---! not a json array, rather than raising. The `text_match` domain CHECK ---! guarantees the `bf` *key* is present but not that it is an array, so a ---! non-array `bf` (e.g. `{"bf": null}`) can reach here even on a typed value; ---! gating on `jsonb_typeof(...) = 'array'` returns NULL for that case — and for ---! raw jsonb outside the domain — instead of erroring inside ---! `jsonb_array_elements`. NULL, like the HMAC extractor, is the right answer. An ---! empty `bf` array yields an empty filter (contains nothing, contained by ---! everything), matching set-containment semantics. ---! ---! @param val jsonb The encrypted payload. ---! @return eql_v3_internal.bloom_filter The `bf` array as a smallint[] domain value, or ---! NULL when `bf` is absent or not a json array. -CREATE FUNCTION eql_v3_internal.bloom_filter(val jsonb) - RETURNS eql_v3_internal.bloom_filter - LANGUAGE sql - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT CASE WHEN jsonb_typeof(val -> 'bf') = 'array' - THEN ARRAY(SELECT jsonb_array_elements(val -> 'bf'))::eql_v3_internal.bloom_filter - END -$$; +--! @brief Operator wrapper for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_smallint_eq) $$; + +--! @brief Operator wrapper for public.eql_v3_smallint_eq. +--! @param a jsonb +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_smallint_eq) $$; + +--! @brief Operator wrapper for public.eql_v3_smallint_eq. +--! @param a jsonb +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a jsonb +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a jsonb +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a jsonb +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a jsonb +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a jsonb +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a jsonb +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param selector text +--! @return public.eql_v3_smallint_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_eq, selector text) +RETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param selector integer +--! @return public.eql_v3_smallint_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_eq, selector integer) +RETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a jsonb +--! @param selector public.eql_v3_smallint_eq +--! @return public.eql_v3_smallint_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint_eq) +RETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a jsonb +--! @param selector public.eql_v3_smallint_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a jsonb +--! @param b public.eql_v3_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a public.eql_v3_smallint_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @param a jsonb +--! @param b public.eql_v3_smallint_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file v3/scalars/smallint/smallint_types.sql ---! @brief Encrypted-domain types for smallint. +--! @file v3/scalars/date/date_types.sql +--! @brief Encrypted-domain types for date. DO $$ BEGIN - --! @brief Encrypted domain public.eql_v3_smallint. + --! @brief Encrypted domain public.eql_v3_date. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_smallint' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_date' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_smallint AS jsonb + CREATE DOMAIN public.eql_v3_date AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1171,14 +1904,14 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_smallint IS 'EQL encrypted smallint (storage only)'; + COMMENT ON DOMAIN public.eql_v3_date IS 'EQL encrypted date (storage only)'; - --! @brief Encrypted domain public.eql_v3_smallint_eq. + --! @brief Encrypted domain public.eql_v3_date_eq. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_smallint_eq' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_date_eq' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_smallint_eq AS jsonb + CREATE DOMAIN public.eql_v3_date_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1189,14 +1922,14 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_smallint_eq IS 'EQL encrypted smallint (equality)'; + COMMENT ON DOMAIN public.eql_v3_date_eq IS 'EQL encrypted date (equality)'; - --! @brief Encrypted domain public.eql_v3_smallint_ord_ore. + --! @brief Encrypted domain public.eql_v3_date_ord_ore. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_smallint_ord_ore' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_date_ord_ore' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_smallint_ord_ore AS jsonb + CREATE DOMAIN public.eql_v3_date_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1209,14 +1942,14 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_smallint_ord_ore IS 'EQL encrypted smallint (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_date_ord_ore IS 'EQL encrypted date (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_smallint_ord. + --! @brief Encrypted domain public.eql_v3_date_ord. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_smallint_ord' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_date_ord' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_smallint_ord AS jsonb + CREATE DOMAIN public.eql_v3_date_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1227,14 +1960,14 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_smallint_ord IS 'EQL encrypted smallint (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_date_ord IS 'EQL encrypted date (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_smallint_ord_ope. + --! @brief Encrypted domain public.eql_v3_date_ord_ope. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_smallint_ord_ope' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_date_ord_ope' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_smallint_ord_ope AS jsonb + CREATE DOMAIN public.eql_v3_date_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1245,22 +1978,22 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_smallint_ord_ope IS 'EQL encrypted smallint (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_date_ord_ope IS 'EQL encrypted date (equality, ordering)'; END $$; -- AUTOMATICALLY GENERATED FILE. ---! @file v3/scalars/real/real_types.sql ---! @brief Encrypted-domain types for real. +--! @file v3/scalars/numeric/numeric_types.sql +--! @brief Encrypted-domain types for numeric. DO $$ BEGIN - --! @brief Encrypted domain public.eql_v3_real. + --! @brief Encrypted domain public.eql_v3_numeric. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_real' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_numeric' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_real AS jsonb + CREATE DOMAIN public.eql_v3_numeric AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1270,14 +2003,14 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_real IS 'EQL encrypted real (storage only)'; + COMMENT ON DOMAIN public.eql_v3_numeric IS 'EQL encrypted numeric (storage only)'; - --! @brief Encrypted domain public.eql_v3_real_eq. + --! @brief Encrypted domain public.eql_v3_numeric_eq. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_real_eq' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_numeric_eq' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_real_eq AS jsonb + CREATE DOMAIN public.eql_v3_numeric_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1288,14 +2021,14 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_real_eq IS 'EQL encrypted real (equality)'; + COMMENT ON DOMAIN public.eql_v3_numeric_eq IS 'EQL encrypted numeric (equality)'; - --! @brief Encrypted domain public.eql_v3_real_ord_ore. + --! @brief Encrypted domain public.eql_v3_numeric_ord_ore. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_real_ord_ore' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_numeric_ord_ore' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_real_ord_ore AS jsonb + CREATE DOMAIN public.eql_v3_numeric_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1308,14 +2041,14 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_real_ord_ore IS 'EQL encrypted real (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_numeric_ord_ore IS 'EQL encrypted numeric (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_real_ord. + --! @brief Encrypted domain public.eql_v3_numeric_ord. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_real_ord' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_numeric_ord' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_real_ord AS jsonb + CREATE DOMAIN public.eql_v3_numeric_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1326,14 +2059,14 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_real_ord IS 'EQL encrypted real (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_numeric_ord IS 'EQL encrypted numeric (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_real_ord_ope. + --! @brief Encrypted domain public.eql_v3_numeric_ord_ope. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_real_ord_ope' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_numeric_ord_ope' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_real_ord_ope AS jsonb + CREATE DOMAIN public.eql_v3_numeric_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1344,22 +2077,22 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_real_ord_ope IS 'EQL encrypted real (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_numeric_ord_ope IS 'EQL encrypted numeric (equality, ordering)'; END $$; -- AUTOMATICALLY GENERATED FILE. ---! @file v3/scalars/numeric/numeric_types.sql ---! @brief Encrypted-domain types for numeric. +--! @file v3/scalars/double/double_types.sql +--! @brief Encrypted-domain types for double. DO $$ BEGIN - --! @brief Encrypted domain public.eql_v3_numeric. + --! @brief Encrypted domain public.eql_v3_double. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_numeric' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_double' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_numeric AS jsonb + CREATE DOMAIN public.eql_v3_double AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1369,14 +2102,14 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_numeric IS 'EQL encrypted numeric (storage only)'; + COMMENT ON DOMAIN public.eql_v3_double IS 'EQL encrypted double (storage only)'; - --! @brief Encrypted domain public.eql_v3_numeric_eq. + --! @brief Encrypted domain public.eql_v3_double_eq. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_numeric_eq' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_double_eq' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_numeric_eq AS jsonb + CREATE DOMAIN public.eql_v3_double_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1387,14 +2120,14 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_numeric_eq IS 'EQL encrypted numeric (equality)'; + COMMENT ON DOMAIN public.eql_v3_double_eq IS 'EQL encrypted double (equality)'; - --! @brief Encrypted domain public.eql_v3_numeric_ord_ore. + --! @brief Encrypted domain public.eql_v3_double_ord_ore. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_numeric_ord_ore' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_double_ord_ore' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_numeric_ord_ore AS jsonb + CREATE DOMAIN public.eql_v3_double_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1407,14 +2140,14 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_numeric_ord_ore IS 'EQL encrypted numeric (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_double_ord_ore IS 'EQL encrypted double (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_numeric_ord. + --! @brief Encrypted domain public.eql_v3_double_ord. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_numeric_ord' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_double_ord' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_numeric_ord AS jsonb + CREATE DOMAIN public.eql_v3_double_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1425,14 +2158,14 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_numeric_ord IS 'EQL encrypted numeric (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_double_ord IS 'EQL encrypted double (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_numeric_ord_ope. + --! @brief Encrypted domain public.eql_v3_double_ord_ope. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_numeric_ord_ope' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_double_ord_ope' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_numeric_ord_ope AS jsonb + CREATE DOMAIN public.eql_v3_double_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1443,11 +2176,440 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_numeric_ord_ope IS 'EQL encrypted numeric (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_double_ord_ope IS 'EQL encrypted double (equality, ordering)'; END $$; -- AUTOMATICALLY GENERATED FILE. +--! @file encrypted_domain/double/double_eq_functions.sql +--! @brief Functions for public.eql_v3_double_eq. + +--! @brief Index extractor for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_double_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b public.eql_v3_double_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_double_eq) $$; + +--! @brief Operator wrapper for public.eql_v3_double_eq. +--! @param a jsonb +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b public.eql_v3_double_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_double_eq) $$; + +--! @brief Operator wrapper for public.eql_v3_double_eq. +--! @param a jsonb +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b public.eql_v3_double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a jsonb +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b public.eql_v3_double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a jsonb +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b public.eql_v3_double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a jsonb +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b public.eql_v3_double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a jsonb +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b public.eql_v3_double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a jsonb +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b public.eql_v3_double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a jsonb +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param selector text +--! @return public.eql_v3_double_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_eq, selector text) +RETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param selector integer +--! @return public.eql_v3_double_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_eq, selector integer) +RETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a jsonb +--! @param selector public.eql_v3_double_eq +--! @return public.eql_v3_double_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double_eq) +RETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a jsonb +--! @param selector public.eql_v3_double_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_eq, b public.eql_v3_double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a jsonb +--! @param b public.eql_v3_double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b public.eql_v3_double_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_eq, b public.eql_v3_double_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @param a jsonb +--! @param b public.eql_v3_double_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + --! @file v3/scalars/integer/integer_types.sql --! @brief Encrypted-domain types for integer. @@ -1547,17 +2709,17 @@ END $$; -- AUTOMATICALLY GENERATED FILE. ---! @file v3/scalars/double/double_types.sql ---! @brief Encrypted-domain types for double. - +--! @file v3/scalars/timestamp/timestamp_types.sql +--! @brief Encrypted-domain types for timestamp. + DO $$ BEGIN - --! @brief Encrypted domain public.eql_v3_double. + --! @brief Encrypted domain public.eql_v3_timestamp. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_double' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_timestamp' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_double AS jsonb + CREATE DOMAIN public.eql_v3_timestamp AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1567,14 +2729,14 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_double IS 'EQL encrypted double (storage only)'; + COMMENT ON DOMAIN public.eql_v3_timestamp IS 'EQL encrypted timestamp (storage only)'; - --! @brief Encrypted domain public.eql_v3_double_eq. + --! @brief Encrypted domain public.eql_v3_timestamp_eq. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_double_eq' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_timestamp_eq' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_double_eq AS jsonb + CREATE DOMAIN public.eql_v3_timestamp_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1585,14 +2747,14 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_double_eq IS 'EQL encrypted double (equality)'; + COMMENT ON DOMAIN public.eql_v3_timestamp_eq IS 'EQL encrypted timestamp (equality)'; - --! @brief Encrypted domain public.eql_v3_double_ord_ore. + --! @brief Encrypted domain public.eql_v3_timestamp_ord_ore. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_double_ord_ore' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_timestamp_ord_ore' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_double_ord_ore AS jsonb + CREATE DOMAIN public.eql_v3_timestamp_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1605,14 +2767,14 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_double_ord_ore IS 'EQL encrypted double (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_timestamp_ord_ore IS 'EQL encrypted timestamp (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_double_ord. + --! @brief Encrypted domain public.eql_v3_timestamp_ord. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_double_ord' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_timestamp_ord' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_double_ord AS jsonb + CREATE DOMAIN public.eql_v3_timestamp_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1623,14 +2785,14 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_double_ord IS 'EQL encrypted double (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_timestamp_ord IS 'EQL encrypted timestamp (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_double_ord_ope. + --! @brief Encrypted domain public.eql_v3_timestamp_ord_ope. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_double_ord_ope' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_timestamp_ord_ope' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_double_ord_ope AS jsonb + CREATE DOMAIN public.eql_v3_timestamp_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1641,22 +2803,22 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_double_ord_ope IS 'EQL encrypted double (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_timestamp_ord_ope IS 'EQL encrypted timestamp (equality, ordering)'; END $$; -- AUTOMATICALLY GENERATED FILE. ---! @file v3/scalars/date/date_types.sql ---! @brief Encrypted-domain types for date. +--! @file v3/scalars/text/text_types.sql +--! @brief Encrypted-domain types for text. DO $$ BEGIN - --! @brief Encrypted domain public.eql_v3_date. + --! @brief Encrypted domain public.eql_v3_text. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_date' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_text' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_date AS jsonb + CREATE DOMAIN public.eql_v3_text AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1666,14 +2828,14 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_date IS 'EQL encrypted date (storage only)'; + COMMENT ON DOMAIN public.eql_v3_text IS 'EQL encrypted text (storage only)'; - --! @brief Encrypted domain public.eql_v3_date_eq. + --! @brief Encrypted domain public.eql_v3_text_eq. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_date_eq' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_text_eq' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_date_eq AS jsonb + CREATE DOMAIN public.eql_v3_text_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -1684,4779 +2846,4726 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_date_eq IS 'EQL encrypted date (equality)'; + COMMENT ON DOMAIN public.eql_v3_text_eq IS 'EQL encrypted text (equality)'; - --! @brief Encrypted domain public.eql_v3_date_ord_ore. + --! @brief Encrypted domain public.eql_v3_text_match. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_date_ord_ore' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_text_match' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_date_ord_ore AS jsonb + CREATE DOMAIN public.eql_v3_text_match AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' - AND VALUE ? 'ob' - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE ? 'bf' AND VALUE->>'v' = '3' ); END IF; - COMMENT ON DOMAIN public.eql_v3_date_ord_ore IS 'EQL encrypted date (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_text_match IS 'EQL encrypted text (matching)'; - --! @brief Encrypted domain public.eql_v3_date_ord. + --! @brief Encrypted domain public.eql_v3_text_ord_ore. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_date_ord' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_text_ord_ore' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_date_ord AS jsonb + CREATE DOMAIN public.eql_v3_text_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' - AND VALUE ? 'op' + AND VALUE ? 'hm' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 AND VALUE->>'v' = '3' ); END IF; - COMMENT ON DOMAIN public.eql_v3_date_ord IS 'EQL encrypted date (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_text_ord_ore IS 'EQL encrypted text (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_date_ord_ope. + --! @brief Encrypted domain public.eql_v3_text_ord. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_date_ord_ope' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_text_ord' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_date_ord_ope AS jsonb + CREATE DOMAIN public.eql_v3_text_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' + AND VALUE ? 'hm' AND VALUE ? 'op' AND VALUE->>'v' = '3' ); END IF; - COMMENT ON DOMAIN public.eql_v3_date_ord_ope IS 'EQL encrypted date (equality, ordering)'; -END -$$; --- AUTOMATICALLY GENERATED FILE. - ---! @file v3/scalars/bigint/bigint_types.sql ---! @brief Encrypted-domain types for bigint. - -DO $$ -BEGIN - --! @brief Encrypted domain public.eql_v3_bigint. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_bigint' AND typnamespace = 'public'::regnamespace - ) THEN - CREATE DOMAIN public.eql_v3_bigint AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN public.eql_v3_bigint IS 'EQL encrypted bigint (storage only)'; + COMMENT ON DOMAIN public.eql_v3_text_ord IS 'EQL encrypted text (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_bigint_eq. + --! @brief Encrypted domain public.eql_v3_text_ord_ope. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_bigint_eq' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_text_ord_ope' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_bigint_eq AS jsonb + CREATE DOMAIN public.eql_v3_text_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' AND VALUE ? 'hm' + AND VALUE ? 'op' AND VALUE->>'v' = '3' ); END IF; - COMMENT ON DOMAIN public.eql_v3_bigint_eq IS 'EQL encrypted bigint (equality)'; + COMMENT ON DOMAIN public.eql_v3_text_ord_ope IS 'EQL encrypted text (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_bigint_ord_ore. + --! @brief Encrypted domain public.eql_v3_text_search_ore. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_bigint_ord_ore' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_text_search_ore' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_bigint_ord_ore AS jsonb + CREATE DOMAIN public.eql_v3_text_search_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' + AND VALUE ? 'hm' AND VALUE ? 'ob' + AND VALUE ? 'bf' AND jsonb_typeof(VALUE -> 'ob') = 'array' AND jsonb_array_length(VALUE -> 'ob') > 0 AND VALUE->>'v' = '3' ); END IF; - COMMENT ON DOMAIN public.eql_v3_bigint_ord_ore IS 'EQL encrypted bigint (equality, ordering)'; - - --! @brief Encrypted domain public.eql_v3_bigint_ord. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_bigint_ord' AND typnamespace = 'public'::regnamespace - ) THEN - CREATE DOMAIN public.eql_v3_bigint_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE ? 'op' - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN public.eql_v3_bigint_ord IS 'EQL encrypted bigint (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_text_search_ore IS 'EQL encrypted text (equality, ordering, matching)'; - --! @brief Encrypted domain public.eql_v3_bigint_ord_ope. + --! @brief Encrypted domain public.eql_v3_text_search. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_bigint_ord_ope' AND typnamespace = 'public'::regnamespace + WHERE typname = 'eql_v3_text_search' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_bigint_ord_ope AS jsonb + CREATE DOMAIN public.eql_v3_text_search AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' + AND VALUE ? 'hm' AND VALUE ? 'op' + AND VALUE ? 'bf' AND VALUE->>'v' = '3' ); END IF; - COMMENT ON DOMAIN public.eql_v3_bigint_ord_ope IS 'EQL encrypted bigint (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_text_search IS 'EQL encrypted text (equality, ordering, matching)'; END $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/timestamp/timestamp_ord_ore_functions.sql ---! @brief Functions for public.eql_v3_timestamp_ord_ore. +--! @file encrypted_domain/text/text_ord_functions.sql +--! @brief Functions for public.eql_v3_text_ord. ---! @brief Index extractor for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_timestamp_ord_ore) -RETURNS eql_v3_internal.ore_block_256 +--! @brief Index extractor for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord) +RETURNS eql_v3_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Index extractor for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_ord) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @brief Operator wrapper for public.eql_v3_text_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @brief Operator wrapper for public.eql_v3_text_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_ord) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @brief Operator wrapper for public.eql_v3_text_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_ord) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @brief Operator wrapper for public.eql_v3_text_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_ord) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @brief Operator wrapper for public.eql_v3_text_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_ord) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @brief Operator wrapper for public.eql_v3_text_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param selector text ---! @return public.eql_v3_timestamp_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ore, selector text) -RETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$ +--! @return public.eql_v3_text_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord, selector text) +RETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param selector integer ---! @return public.eql_v3_timestamp_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ore, selector integer) -RETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$ +--! @return public.eql_v3_text_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord, selector integer) +RETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. --! @param a jsonb ---! @param selector public.eql_v3_timestamp_ord_ore ---! @return public.eql_v3_timestamp_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_ord_ore) -RETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$ +--! @param selector public.eql_v3_text_ord +--! @return public.eql_v3_text_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_ord) +RETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ore, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ore, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. --! @param a jsonb ---! @param selector public.eql_v3_timestamp_ord_ore +--! @param selector public.eql_v3_text_ord --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_ord) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b jsonpath +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b public.eql_v3_text_ord --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a jsonb +--! @param b public.eql_v3_text_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_text_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ore, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b public.eql_v3_text_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @param a public.eql_v3_text_ord --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_text_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; + +--! @file v3/sem/bloom_filter/functions.sql +--! @brief Extractor for the eql_v3 Bloom-filter SEM index term. +--! +--! jsonb-only subset of src/bloom_filter/functions.sql. The encrypted-column +--! overloads are intentionally omitted — the eql_v3 scalar domains extract from +--! the jsonb payload directly via a cast to the domain. (Doc comments +--! deliberately avoid naming eql_v2 symbols so the self-containment grep stays +--! clean.) + +--! @brief Test whether a jsonb payload carries a Bloom-filter (`bf`) term. +--! +--! @param val jsonb The encrypted payload. +--! @return boolean True when the `bf` key is present and non-null. +--! +--! @internal Defined for parity with the eql_v3 SEM index-term predicates +--! (`has_hmac_256` / `has_ore_block_256`); it is not currently called by +--! the extractor below, which gates on value-shape inline, nor by the generated +--! domain CHECK, which tests `bf` presence via the envelope-key skeleton. Kept +--! as the canonical presence test for callers that need one. +CREATE FUNCTION eql_v3_internal.has_bloom_filter(val jsonb) + RETURNS boolean + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + BEGIN + RETURN val ? 'bf' AND val ->> 'bf' IS NOT NULL; + END; +$$ LANGUAGE plpgsql; + +--! @brief Extract the Bloom-filter index term from a jsonb payload. +--! +--! Inlinable single-statement SQL — the planner can fold this into the calling +--! query so the functional GIN index built on `eql_v3_internal.match_term(col)` (which +--! calls this) engages structurally. Mirrors `eql_v3_internal.hmac_256(jsonb)`: no RAISE +--! and no pinned `search_path`. Returns NULL when `bf` is absent or present but +--! not a json array, rather than raising. The `text_match` domain CHECK +--! guarantees the `bf` *key* is present but not that it is an array, so a +--! non-array `bf` (e.g. `{"bf": null}`) can reach here even on a typed value; +--! gating on `jsonb_typeof(...) = 'array'` returns NULL for that case — and for +--! raw jsonb outside the domain — instead of erroring inside +--! `jsonb_array_elements`. NULL, like the HMAC extractor, is the right answer. An +--! empty `bf` array yields an empty filter (contains nothing, contained by +--! everything), matching set-containment semantics. +--! +--! @param val jsonb The encrypted payload. +--! @return eql_v3_internal.bloom_filter The `bf` array as a smallint[] domain value, or +--! NULL when `bf` is absent or not a json array. +CREATE FUNCTION eql_v3_internal.bloom_filter(val jsonb) + RETURNS eql_v3_internal.bloom_filter + LANGUAGE sql + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT CASE WHEN jsonb_typeof(val -> 'bf') = 'array' + THEN ARRAY(SELECT jsonb_array_elements(val -> 'bf'))::eql_v3_internal.bloom_filter + END +$$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/timestamp/timestamp_ord_ope_functions.sql ---! @brief Functions for public.eql_v3_timestamp_ord_ope. +--! @file encrypted_domain/timestamp/timestamp_eq_functions.sql +--! @brief Functions for public.eql_v3_timestamp_eq. ---! @brief Index extractor for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_timestamp_ord_ope) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_timestamp_eq) +RETURNS eql_v3_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Operator wrapper for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Operator wrapper for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_timestamp_eq) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @brief Operator wrapper for public.eql_v3_timestamp_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Operator wrapper for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Operator wrapper for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_timestamp_eq) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @brief Operator wrapper for public.eql_v3_timestamp_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) < eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) <= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) > eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) >= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param selector text ---! @return public.eql_v3_timestamp_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ope, selector text) -RETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$ +--! @return public.eql_v3_timestamp_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_eq, selector text) +RETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param selector integer ---! @return public.eql_v3_timestamp_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ope, selector integer) -RETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$ +--! @return public.eql_v3_timestamp_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_eq, selector integer) +RETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. --! @param a jsonb ---! @param selector public.eql_v3_timestamp_ord_ope ---! @return public.eql_v3_timestamp_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_ord_ope) -RETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$ +--! @param selector public.eql_v3_timestamp_eq +--! @return public.eql_v3_timestamp_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_eq) +RETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ope, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ope, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. --! @param a jsonb ---! @param selector public.eql_v3_timestamp_ord_ope +--! @param selector public.eql_v3_timestamp_eq --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_eq) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_ord_ope, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b jsonpath +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b public.eql_v3_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ope, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ope, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b public.eql_v3_timestamp_eq --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_eq --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/timestamp/timestamp_ord_functions.sql ---! @brief Functions for public.eql_v3_timestamp_ord. +--! @file v3/scalars/bigint/bigint_types.sql +--! @brief Encrypted-domain types for bigint. ---! @brief Index extractor for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_timestamp_ord) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +DO $$ +BEGIN + --! @brief Encrypted domain public.eql_v3_bigint. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'eql_v3_bigint' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.eql_v3_bigint AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b public.eql_v3_timestamp_ord + COMMENT ON DOMAIN public.eql_v3_bigint IS 'EQL encrypted bigint (storage only)'; + + --! @brief Encrypted domain public.eql_v3_bigint_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'eql_v3_bigint_eq' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.eql_v3_bigint_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'hm' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.eql_v3_bigint_eq IS 'EQL encrypted bigint (equality)'; + + --! @brief Encrypted domain public.eql_v3_bigint_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'eql_v3_bigint_ord_ore' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.eql_v3_bigint_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.eql_v3_bigint_ord_ore IS 'EQL encrypted bigint (equality, ordering)'; + + --! @brief Encrypted domain public.eql_v3_bigint_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'eql_v3_bigint_ord' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.eql_v3_bigint_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'op' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.eql_v3_bigint_ord IS 'EQL encrypted bigint (equality, ordering)'; + + --! @brief Encrypted domain public.eql_v3_bigint_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'eql_v3_bigint_ord_ope' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.eql_v3_bigint_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'op' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.eql_v3_bigint_ord_ope IS 'EQL encrypted bigint (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_functions.sql +--! @brief Functions for public.eql_v3_bigint. + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b public.eql_v3_bigint --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$; +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.eql_v3_bigint. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord +--! @param b public.eql_v3_bigint --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) = eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b public.eql_v3_bigint --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$; +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.eql_v3_bigint. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord +--! @param b public.eql_v3_bigint --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) <> eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b public.eql_v3_bigint --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.eql_v3_bigint. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord +--! @param b public.eql_v3_bigint --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) < eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b public.eql_v3_bigint --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.eql_v3_bigint. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord +--! @param b public.eql_v3_bigint --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) <= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b public.eql_v3_bigint --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.eql_v3_bigint. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord +--! @param b public.eql_v3_bigint --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) > eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b public.eql_v3_bigint --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.eql_v3_bigint. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord +--! @param b public.eql_v3_bigint --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) >= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b public.eql_v3_bigint --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.eql_v3_bigint. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord +--! @param b public.eql_v3_bigint --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b public.eql_v3_bigint --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.eql_v3_bigint. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord +--! @param b public.eql_v3_bigint --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param selector text ---! @return public.eql_v3_timestamp_ord -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord, selector text) -RETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$ +--! @return public.eql_v3_bigint +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint, selector text) +RETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param selector integer ---! @return public.eql_v3_timestamp_ord -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord, selector integer) -RETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$ +--! @return public.eql_v3_bigint +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint, selector integer) +RETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.eql_v3_bigint. --! @param a jsonb ---! @param selector public.eql_v3_timestamp_ord ---! @return public.eql_v3_timestamp_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_ord) -RETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$ +--! @param selector public.eql_v3_bigint +--! @return public.eql_v3_bigint +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint) +RETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.eql_v3_bigint. --! @param a jsonb ---! @param selector public.eql_v3_timestamp_ord +--! @param selector public.eql_v3_bigint --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_ord) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_ord, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b public.eql_v3_bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a jsonb +--! @param b public.eql_v3_bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint +--! @param b public.eql_v3_bigint --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint, b public.eql_v3_bigint) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @param a public.eql_v3_bigint --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.eql_v3_bigint. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord +--! @param b public.eql_v3_bigint --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_ord) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file v3/scalars/timestamp/query_timestamp_types.sql ---! @brief Query-operand domains for timestamp (index-terms-only, no ciphertext). ---! @note Query-operand domains live in `eql_v3` (not `public`): they are ---! never valid column types, so they don't belong in the column-type ---! namespace, and dropping the EQL-owned schema can never drop an ---! application column. ---! @note Cast a query operand explicitly to its `query_` domain in a predicate ---! (e.g. `WHERE col = $1::eql_v3.query_timestamp_eq`). A bare, ---! uncast literal RHS is ambiguous between the `query_` and `jsonb` ---! operator overloads and will not resolve. - -DO $$ -BEGIN - --! @brief Query-operand domain eql_v3.query_timestamp_eq (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_timestamp_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_timestamp_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'hm' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_timestamp_eq IS 'EQL timestamp query operand (equality)'; - - --! @brief Query-operand domain eql_v3.query_timestamp_ord_ore (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_timestamp_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_timestamp_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'ob' - AND NOT (VALUE ? 'c') - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_timestamp_ord_ore IS 'EQL timestamp query operand (equality, ordering)'; - - --! @brief Query-operand domain eql_v3.query_timestamp_ord (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_timestamp_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_timestamp_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'op' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_timestamp_ord IS 'EQL timestamp query operand (equality, ordering)'; - - --! @brief Query-operand domain eql_v3.query_timestamp_ord_ope (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_timestamp_ord_ope' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_timestamp_ord_ope AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'op' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_timestamp_ord_ope IS 'EQL timestamp query operand (equality, ordering)'; -END -$$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/timestamp_eq_functions.sql ---! @brief Functions for public.eql_v3_timestamp_eq. +--! @file encrypted_domain/bigint/bigint_ord_functions.sql +--! @brief Functions for public.eql_v3_bigint_ord. ---! @brief Index extractor for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_timestamp_eq) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_bigint_ord) +RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq +--! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_timestamp_eq) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_eq. +--! @brief Operator wrapper for public.eql_v3_bigint_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_eq +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_eq) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq +--! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_timestamp_eq) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_eq. +--! @brief Operator wrapper for public.eql_v3_bigint_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_eq +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_eq) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) <> eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq +--! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Operator wrapper for public.eql_v3_bigint_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_eq +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq +--! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Operator wrapper for public.eql_v3_bigint_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_eq +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq +--! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Operator wrapper for public.eql_v3_bigint_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_eq +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq +--! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Operator wrapper for public.eql_v3_bigint_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_eq +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_eq +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_eq) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_eq +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_eq) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param selector text ---! @return public.eql_v3_timestamp_eq -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_eq, selector text) -RETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$ +--! @return public.eql_v3_bigint_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord, selector text) +RETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param selector integer ---! @return public.eql_v3_timestamp_eq -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_eq, selector integer) -RETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$ +--! @return public.eql_v3_bigint_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord, selector integer) +RETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. --! @param a jsonb ---! @param selector public.eql_v3_timestamp_eq ---! @return public.eql_v3_timestamp_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_eq) -RETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$ +--! @param selector public.eql_v3_bigint_ord +--! @return public.eql_v3_bigint_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_ord) +RETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_eq, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_eq, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. --! @param a jsonb ---! @param selector public.eql_v3_timestamp_eq +--! @param selector public.eql_v3_bigint_ord --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_eq) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_ord) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_eq, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b public.eql_v3_bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a jsonb +--! @param b public.eql_v3_bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_bigint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_eq, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_eq, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_eq, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @param a public.eql_v3_bigint_ord --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_eq, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_eq +--! @param b public.eql_v3_bigint_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_eq) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_search_ore_functions.sql ---! @brief Functions for public.eql_v3_text_search_ore. +--! @file v3/scalars/bigint/query_bigint_types.sql +--! @brief Query-operand domains for bigint (index-terms-only, no ciphertext). +--! @note Query-operand domains live in `eql_v3` (not `public`): they are +--! never valid column types, so they don't belong in the column-type +--! namespace, and dropping the EQL-owned schema can never drop an +--! application column. +--! @note Cast a query operand explicitly to its `query_` domain in a predicate +--! (e.g. `WHERE col = $1::eql_v3.query_bigint_eq`). A bare, +--! uncast literal RHS is ambiguous between the `query_` and `jsonb` +--! operator overloads and will not resolve. ---! @brief Index extractor for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_search_ore) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +DO $$ +BEGIN + --! @brief Query-operand domain eql_v3.query_bigint_eq (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_bigint_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_bigint_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Index extractor for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore + COMMENT ON DOMAIN eql_v3.query_bigint_eq IS 'EQL bigint query operand (equality)'; + + --! @brief Query-operand domain eql_v3.query_bigint_ord_ore (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_bigint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_bigint_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_bigint_ord_ore IS 'EQL bigint query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_bigint_ord (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_bigint_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_bigint_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_bigint_ord IS 'EQL bigint query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_bigint_ord_ope (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_bigint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_bigint_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_bigint_ord_ope IS 'EQL bigint query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ore_functions.sql +--! @brief Functions for public.eql_v3_bigint_ord_ore. + +--! @brief Index extractor for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_text_search_ore) +CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_bigint_ord_ore) RETURNS eql_v3_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; ---! @brief Index extractor for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @return eql_v3_internal.bloom_filter -CREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_search_ore) -RETURNS eql_v3_internal.bloom_filter -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; - ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_search_ore) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_text_search_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_search_ore) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search_ore) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_search_ore) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_text_search_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_search_ore) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search_ore) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) <> eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_text_search_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_search_ore) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) < eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_text_search_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_search_ore) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) <= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_text_search_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_search_ore) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) > eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_text_search_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_search_ore) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) >= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.contains(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contains(a public.eql_v3_text_search_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search_ore) $$; +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_text_search_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b public.eql_v3_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search_ore) @> eql_v3.match_term(b) $$; +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_search_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b::public.eql_v3_text_search_ore) $$; +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_text_search_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b public.eql_v3_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search_ore) <@ eql_v3.match_term(b) $$; - ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param selector text ---! @return public.eql_v3_text_search_ore -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search_ore, selector text) -RETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$ +--! @return public.eql_v3_bigint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ore, selector text) +RETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param selector integer ---! @return public.eql_v3_text_search_ore -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search_ore, selector integer) -RETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$ +--! @return public.eql_v3_bigint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ore, selector integer) +RETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. --! @param a jsonb ---! @param selector public.eql_v3_text_search_ore ---! @return public.eql_v3_text_search_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_search_ore) -RETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$ +--! @param selector public.eql_v3_bigint_ord_ore +--! @return public.eql_v3_bigint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_ord_ore) +RETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search_ore, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search_ore, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. --! @param a jsonb ---! @param selector public.eql_v3_text_search_ore +--! @param selector public.eql_v3_bigint_ord_ore --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_search_ore) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_search_ore, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_search_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_search_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_search_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_search_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_search_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_search_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search_ore, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search_ore, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search_ore, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_search_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search_ore, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_text_search_ore +--! @param b public.eql_v3_bigint_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_search_ore) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_search_functions.sql ---! @brief Functions for public.eql_v3_text_search. +--! @file encrypted_domain/bigint/bigint_ord_ore_operators.sql +--! @brief Operators for public.eql_v3_bigint_ord_ore. ---! @brief Index extractor for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_search) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Index extractor for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_search) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Index extractor for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @return eql_v3_internal.bloom_filter -CREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_search) -RETURNS eql_v3_internal.bloom_filter -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_search) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a jsonb ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search) = eql_v3.eq_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_search) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a jsonb ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_search) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a jsonb ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) < eql_v3.ord_term(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_search) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a jsonb ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_search) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a jsonb ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) > eql_v3.ord_term(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_search) $$; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a jsonb ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) >= eql_v3.ord_term(b) $$; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.contains(a public.eql_v3_text_search, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.contains(a public.eql_v3_text_search, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search) $$; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a jsonb ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search) @> eql_v3.match_term(b) $$; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_search, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_search, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b::public.eql_v3_text_search) $$; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer +); ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a jsonb ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search) <@ eql_v3.match_term(b) $$; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param selector text ---! @return public.eql_v3_text_search -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search, selector text) -RETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param selector integer ---! @return public.eql_v3_text_search -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search, selector integer) -RETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a jsonb ---! @param selector public.eql_v3_text_search ---! @return public.eql_v3_text_search -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_search) -RETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a jsonb ---! @param selector public.eql_v3_text_search ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_search) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_search, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonpath +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_search, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_search, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_search, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_search, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonpath +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_search, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_search, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_search, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b public.eql_v3_text_search ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search, b public.eql_v3_text_search) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a jsonb ---! @param b public.eql_v3_text_search ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_search) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore +); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_ord_ore_functions.sql ---! @brief Functions for public.eql_v3_text_ord_ore. +--! @file encrypted_domain/bigint/bigint_ord_operators.sql +--! @brief Operators for public.eql_v3_bigint_ord. ---! @brief Index extractor for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord_ore) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Index extractor for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_text_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord_ore) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ore) = eql_v3.eq_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord_ore) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ore) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) < eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) <= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) > eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord +); ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) >= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ore) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param selector text ---! @return public.eql_v3_text_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ore, selector text) -RETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param selector integer ---! @return public.eql_v3_text_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ore, selector integer) -RETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_text_ord_ore ---! @return public.eql_v3_text_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_ord_ore) -RETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ore, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ore, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_text_ord_ore ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_ord_ore) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_ord_ore, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonpath +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_ord_ore, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ore, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonpath +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_ord_ore, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ore, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ore, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_ord_ore, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ore, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ore ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_ord_ore) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb +); ---! @file encrypted_domain/text/text_ord_ope_functions.sql ---! @brief Functions for public.eql_v3_text_ord_ope. +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Index extractor for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord_ope) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +--! @file encrypted_domain/bigint/query_bigint_ord_functions.sql +--! @brief Functions for eql_v3.query_bigint_ord. ---! @brief Index extractor for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope +--! @brief Index extractor for eql_v3.query_bigint_ord. +--! @param a eql_v3.query_bigint_ord --! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_ord_ope) +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_bigint_ord) RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b public.eql_v3_text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord_ope) $$; - ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ope +--! @brief Operator wrapper for eql_v3.query_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b eql_v3.query_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord_ope) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ope) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b public.eql_v3_text_ord_ope +--! @brief Operator wrapper for eql_v3.query_bigint_ord. +--! @param a eql_v3.query_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +CREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b eql_v3.query_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ope +--! @brief Operator wrapper for eql_v3.query_bigint_ord. +--! @param a eql_v3.query_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord_ope) +CREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ope) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b public.eql_v3_text_ord_ope +--! @brief Operator wrapper for eql_v3.query_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b eql_v3.query_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$; - ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ope +--! @brief Operator wrapper for eql_v3.query_bigint_ord. +--! @param a eql_v3.query_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord_ope) +CREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b public.eql_v3_text_ord_ope +--! @brief Operator wrapper for eql_v3.query_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b eql_v3.query_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$; - ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ope +--! @brief Operator wrapper for eql_v3.query_bigint_ord. +--! @param a eql_v3.query_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord_ope) +CREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b public.eql_v3_text_ord_ope +--! @brief Operator wrapper for eql_v3.query_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b eql_v3.query_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$; - ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ope +--! @brief Operator wrapper for eql_v3.query_bigint_ord. +--! @param a eql_v3.query_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord_ope) +CREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b public.eql_v3_text_ord_ope +--! @brief Operator wrapper for eql_v3.query_bigint_ord. +--! @param a public.eql_v3_bigint_ord +--! @param b eql_v3.query_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_bigint_ord. +--! @param a eql_v3.query_bigint_ord +--! @param b public.eql_v3_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) >= eql_v3.ord_term(b) $$; +--! @file v3/scalars/real/query_real_types.sql +--! @brief Query-operand domains for real (index-terms-only, no ciphertext). +--! @note Query-operand domains live in `eql_v3` (not `public`): they are +--! never valid column types, so they don't belong in the column-type +--! namespace, and dropping the EQL-owned schema can never drop an +--! application column. +--! @note Cast a query operand explicitly to its `query_` domain in a predicate +--! (e.g. `WHERE col = $1::eql_v3.query_real_eq`). A bare, +--! uncast literal RHS is ambiguous between the `query_` and `jsonb` +--! operator overloads and will not resolve. ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b public.eql_v3_text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; +DO $$ +BEGIN + --! @brief Query-operand domain eql_v3.query_real_eq (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_real_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_real_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; + COMMENT ON DOMAIN eql_v3.query_real_eq IS 'EQL real query operand (equality)'; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b public.eql_v3_text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; + --! @brief Query-operand domain eql_v3.query_real_ord_ore (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_real_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_real_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; + COMMENT ON DOMAIN eql_v3.query_real_ord_ore IS 'EQL real query operand (equality, ordering)'; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param selector text ---! @return public.eql_v3_text_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ope, selector text) -RETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; + --! @brief Query-operand domain eql_v3.query_real_ord (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_real_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_real_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param selector integer ---! @return public.eql_v3_text_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ope, selector integer) -RETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; + COMMENT ON DOMAIN eql_v3.query_real_ord IS 'EQL real query operand (equality, ordering)'; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_text_ord_ope ---! @return public.eql_v3_text_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_ord_ope) -RETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; + --! @brief Query-operand domain eql_v3.query_real_ord_ope (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_real_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_real_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ope, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; + COMMENT ON DOMAIN eql_v3.query_real_ord_ope IS 'EQL real query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ope, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/real/query_real_ord_ore_functions.sql +--! @brief Functions for eql_v3.query_real_ord_ore. ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_text_ord_ope ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_ord_ope) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; +--! @brief Index extractor for eql_v3.query_real_ord_ore. +--! @param a eql_v3.query_real_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_real_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text +--! @brief Operator wrapper for eql_v3.query_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b eql_v3.query_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_ord_ope, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text[] +--! @brief Operator wrapper for eql_v3.query_real_ord_ore. +--! @param a eql_v3.query_real_ord_ore +--! @param b public.eql_v3_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text[] +--! @brief Operator wrapper for eql_v3.query_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b eql_v3.query_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonpath +--! @brief Operator wrapper for eql_v3.query_real_ord_ore. +--! @param a eql_v3.query_real_ord_ore +--! @param b public.eql_v3_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonpath +--! @brief Operator wrapper for eql_v3.query_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b eql_v3.query_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_ord_ope, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ope, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_real_ord_ore. +--! @param a eql_v3.query_real_ord_ore +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ope, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b eql_v3.query_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_real_ord_ore. +--! @param a eql_v3.query_real_ord_ore +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b eql_v3.query_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b public.eql_v3_text_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_real_ord_ore. +--! @param a eql_v3.query_real_ord_ore +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ope, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_real_ord_ore. +--! @param a public.eql_v3_real_ord_ore +--! @param b eql_v3.query_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$ -LANGUAGE plpgsql; +--! @brief Operator wrapper for eql_v3.query_real_ord_ore. +--! @param a eql_v3.query_real_ord_ore +--! @param b public.eql_v3_real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_ord_functions.sql ---! @brief Functions for public.eql_v3_text_ord. - ---! @brief Index extractor for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +--! @file encrypted_domain/real/real_ord_functions.sql +--! @brief Functions for public.eql_v3_real_ord. ---! @brief Index extractor for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Index extractor for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_ord) +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_real_ord) RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b public.eql_v3_text_ord +--! @brief Operator wrapper for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b public.eql_v3_text_ord) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Operator wrapper for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_real_ord) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. +--! @brief Operator wrapper for public.eql_v3_real_ord. --! @param a jsonb ---! @param b public.eql_v3_text_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b public.eql_v3_text_ord +--! @brief Operator wrapper for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b public.eql_v3_text_ord) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Operator wrapper for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_real_ord) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. +--! @brief Operator wrapper for public.eql_v3_real_ord. --! @param a jsonb ---! @param b public.eql_v3_text_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b public.eql_v3_text_ord +--! @brief Operator wrapper for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b public.eql_v3_text_ord) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Operator wrapper for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_real_ord) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. +--! @brief Operator wrapper for public.eql_v3_real_ord. --! @param a jsonb ---! @param b public.eql_v3_text_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b public.eql_v3_text_ord +--! @brief Operator wrapper for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b public.eql_v3_text_ord) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Operator wrapper for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_real_ord) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. +--! @brief Operator wrapper for public.eql_v3_real_ord. --! @param a jsonb ---! @param b public.eql_v3_text_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b public.eql_v3_text_ord +--! @brief Operator wrapper for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b public.eql_v3_text_ord) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Operator wrapper for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_real_ord) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. +--! @brief Operator wrapper for public.eql_v3_real_ord. --! @param a jsonb ---! @param b public.eql_v3_text_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b public.eql_v3_text_ord +--! @brief Operator wrapper for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b public.eql_v3_text_ord) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Operator wrapper for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_real_ord) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. +--! @brief Operator wrapper for public.eql_v3_real_ord. --! @param a jsonb ---! @param b public.eql_v3_text_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b public.eql_v3_text_ord) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. --! @param a jsonb ---! @param b public.eql_v3_text_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b public.eql_v3_text_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. --! @param a jsonb ---! @param b public.eql_v3_text_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param selector text ---! @return public.eql_v3_text_ord -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord, selector text) -RETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$ +--! @return public.eql_v3_real_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord, selector text) +RETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param selector integer ---! @return public.eql_v3_text_ord -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord, selector integer) -RETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$ +--! @return public.eql_v3_real_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord, selector integer) +RETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. --! @param a jsonb ---! @param selector public.eql_v3_text_ord ---! @return public.eql_v3_text_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_ord) -RETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$ +--! @param selector public.eql_v3_real_ord +--! @return public.eql_v3_real_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_ord) +RETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. --! @param a jsonb ---! @param selector public.eql_v3_text_ord +--! @param selector public.eql_v3_real_ord --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_ord) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_ord) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_ord, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b public.eql_v3_real_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord, b public.eql_v3_real_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a jsonb +--! @param b public.eql_v3_real_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_real_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b public.eql_v3_real_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord, b public.eql_v3_text_ord) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @param a public.eql_v3_real_ord --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. --! @param a jsonb ---! @param b public.eql_v3_text_ord +--! @param b public.eql_v3_real_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_ord) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file v3/scalars/text/query_text_types.sql ---! @brief Query-operand domains for text (index-terms-only, no ciphertext). ---! @note Query-operand domains live in `eql_v3` (not `public`): they are ---! never valid column types, so they don't belong in the column-type ---! namespace, and dropping the EQL-owned schema can never drop an ---! application column. ---! @note Cast a query operand explicitly to its `query_` domain in a predicate ---! (e.g. `WHERE col = $1::eql_v3.query_text_eq`). A bare, ---! uncast literal RHS is ambiguous between the `query_` and `jsonb` ---! operator overloads and will not resolve. - -DO $$ -BEGIN - --! @brief Query-operand domain eql_v3.query_text_eq (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_text_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_text_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'hm' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_text_eq IS 'EQL text query operand (equality)'; - - --! @brief Query-operand domain eql_v3.query_text_match (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_text_match' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_text_match AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'bf' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_text_match IS 'EQL text query operand (containment)'; - - --! @brief Query-operand domain eql_v3.query_text_ord_ore (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_text_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_text_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'hm' - AND VALUE ? 'ob' - AND NOT (VALUE ? 'c') - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_text_ord_ore IS 'EQL text query operand (equality, ordering)'; - - --! @brief Query-operand domain eql_v3.query_text_ord (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_text_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_text_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'hm' - AND VALUE ? 'op' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_text_ord IS 'EQL text query operand (equality, ordering)'; - - --! @brief Query-operand domain eql_v3.query_text_ord_ope (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_text_ord_ope' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_text_ord_ope AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'hm' - AND VALUE ? 'op' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; +--! @file encrypted_domain/real/real_eq_functions.sql +--! @brief Functions for public.eql_v3_real_eq. - COMMENT ON DOMAIN eql_v3.query_text_ord_ope IS 'EQL text query operand (equality, ordering)'; +--! @brief Index extractor for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_real_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - --! @brief Query-operand domain eql_v3.query_text_search_ore (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_text_search_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_text_search_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'hm' - AND VALUE ? 'ob' - AND VALUE ? 'bf' - AND NOT (VALUE ? 'c') - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; +--! @brief Operator wrapper for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b public.eql_v3_real_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - COMMENT ON DOMAIN eql_v3.query_text_search_ore IS 'EQL text query operand (equality, ordering, containment)'; +--! @brief Operator wrapper for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_real_eq) $$; - --! @brief Query-operand domain eql_v3.query_text_search (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_text_search' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_text_search AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'hm' - AND VALUE ? 'op' - AND VALUE ? 'bf' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; +--! @brief Operator wrapper for public.eql_v3_real_eq. +--! @param a jsonb +--! @param b public.eql_v3_real_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) = eql_v3.eq_term(b) $$; - COMMENT ON DOMAIN eql_v3.query_text_search IS 'EQL text query operand (equality, ordering, containment)'; -END -$$; --- AUTOMATICALLY GENERATED FILE. +--! @brief Operator wrapper for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b public.eql_v3_real_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @file encrypted_domain/text/text_match_functions.sql ---! @brief Functions for public.eql_v3_text_match. +--! @brief Operator wrapper for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_real_eq) $$; ---! @brief Index extractor for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @return eql_v3_internal.bloom_filter -CREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_match) -RETURNS eql_v3_internal.bloom_filter -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; +--! @brief Operator wrapper for public.eql_v3_real_eq. +--! @param a jsonb +--! @param b public.eql_v3_real_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) <> eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b public.eql_v3_real_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b public.eql_v3_text_match) +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b jsonb) +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. --! @param a jsonb ---! @param b public.eql_v3_text_match +--! @param b public.eql_v3_real_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text_match) +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b public.eql_v3_real_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b public.eql_v3_text_match) +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b jsonb) +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. --! @param a jsonb ---! @param b public.eql_v3_text_match +--! @param b public.eql_v3_real_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text_match) +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b public.eql_v3_real_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b public.eql_v3_text_match) +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b jsonb) +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. --! @param a jsonb ---! @param b public.eql_v3_text_match +--! @param b public.eql_v3_real_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_match) +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b public.eql_v3_real_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b public.eql_v3_text_match) +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b jsonb) +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. --! @param a jsonb ---! @param b public.eql_v3_text_match +--! @param b public.eql_v3_real_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_match) +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b public.eql_v3_real_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b public.eql_v3_text_match) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. --! @param a jsonb ---! @param b public.eql_v3_text_match +--! @param b public.eql_v3_real_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_match) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b public.eql_v3_real_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b public.eql_v3_text_match) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. --! @param a jsonb ---! @param b public.eql_v3_text_match +--! @param b public.eql_v3_real_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_match) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match ---! @return boolean -CREATE FUNCTION eql_v3.contains(a public.eql_v3_text_match, b public.eql_v3_text_match) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; - ---! @brief Operator wrapper for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.contains(a public.eql_v3_text_match, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_match) $$; - ---! @brief Operator wrapper for public.eql_v3_text_match. ---! @param a jsonb ---! @param b public.eql_v3_text_match ---! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b public.eql_v3_text_match) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_match) @> eql_v3.match_term(b) $$; - ---! @brief Operator wrapper for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_match, b public.eql_v3_text_match) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; - ---! @brief Operator wrapper for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_match, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b::public.eql_v3_text_match) $$; - ---! @brief Operator wrapper for public.eql_v3_text_match. ---! @param a jsonb ---! @param b public.eql_v3_text_match ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b public.eql_v3_text_match) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_match) <@ eql_v3.match_term(b) $$; - ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param selector text ---! @return public.eql_v3_text_match -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_match, selector text) -RETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$ +--! @return public.eql_v3_real_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_eq, selector text) +RETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param selector integer ---! @return public.eql_v3_text_match -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_match, selector integer) -RETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$ +--! @return public.eql_v3_real_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_eq, selector integer) +RETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. --! @param a jsonb ---! @param selector public.eql_v3_text_match ---! @return public.eql_v3_text_match -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_match) -RETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$ +--! @param selector public.eql_v3_real_eq +--! @return public.eql_v3_real_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_eq) +RETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_match, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_match, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. --! @param a jsonb ---! @param selector public.eql_v3_text_match +--! @param selector public.eql_v3_real_eq --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_match) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_eq) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_match, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_match, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_match, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_match, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b public.eql_v3_real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a jsonb +--! @param b public.eql_v3_real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_match, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_match, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_match, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_match, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_match, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_match, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_match, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b public.eql_v3_real_eq --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_match, b public.eql_v3_text_match) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @param a public.eql_v3_real_eq --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_match, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. --! @param a jsonb ---! @param b public.eql_v3_text_match +--! @param b public.eql_v3_real_eq --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_match) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_eq_functions.sql ---! @brief Functions for public.eql_v3_text_eq. +--! @file encrypted_domain/real/real_ord_ope_functions.sql +--! @brief Functions for public.eql_v3_real_ord_ope. ---! @brief Index extractor for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_eq) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_real_ord_ope) +RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b public.eql_v3_text_eq) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_eq) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_text_eq. +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text_eq +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_eq) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b public.eql_v3_text_eq) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_eq) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_text_eq. +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text_eq +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_eq) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) <> eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b public.eql_v3_text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text_eq +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b public.eql_v3_text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text_eq +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b public.eql_v3_text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text_eq +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b public.eql_v3_text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$; + +--! @brief Operator wrapper for public.eql_v3_real_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text_eq +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b public.eql_v3_text_eq) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text_eq +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_eq) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b public.eql_v3_text_eq) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text_eq +--! @param b public.eql_v3_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_eq) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param selector text ---! @return public.eql_v3_text_eq -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_eq, selector text) -RETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$ +--! @return public.eql_v3_real_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ope, selector text) +RETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param selector integer ---! @return public.eql_v3_text_eq -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_eq, selector integer) -RETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$ +--! @return public.eql_v3_real_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ope, selector integer) +RETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. --! @param a jsonb ---! @param selector public.eql_v3_text_eq ---! @return public.eql_v3_text_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_eq) -RETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$ +--! @param selector public.eql_v3_real_ord_ope +--! @return public.eql_v3_real_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_ord_ope) +RETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_eq, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_eq, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. --! @param a jsonb ---! @param selector public.eql_v3_text_eq +--! @param selector public.eql_v3_real_ord_ope --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_eq) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_eq, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b public.eql_v3_real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_real_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_eq, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_eq, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_eq, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b public.eql_v3_real_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_eq, b public.eql_v3_text_eq) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_eq, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text_eq +--! @param b public.eql_v3_real_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_eq) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. +--! @file encrypted_domain/real/query_real_eq_functions.sql +--! @brief Functions for eql_v3.query_real_eq. + +--! @brief Index extractor for eql_v3.query_real_eq. +--! @param a eql_v3.query_real_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_real_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b eql_v3.query_real_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b eql_v3.query_real_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_real_eq. +--! @param a eql_v3.query_real_eq +--! @param b public.eql_v3_real_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_real_eq, b public.eql_v3_real_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_real_eq. +--! @param a public.eql_v3_real_eq +--! @param b eql_v3.query_real_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b eql_v3.query_real_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_real_eq. +--! @param a eql_v3.query_real_eq +--! @param b public.eql_v3_real_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_real_eq, b public.eql_v3_real_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/query_real_ord_ope_functions.sql +--! @brief Functions for eql_v3.query_real_ord_ope. + +--! @brief Index extractor for eql_v3.query_real_ord_ope. +--! @param a eql_v3.query_real_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_real_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b eql_v3.query_real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_real_ord_ope. +--! @param a eql_v3.query_real_ord_ope +--! @param b public.eql_v3_real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b eql_v3.query_real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_real_ord_ope. +--! @param a eql_v3.query_real_ord_ope +--! @param b public.eql_v3_real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b eql_v3.query_real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_real_ord_ope. +--! @param a eql_v3.query_real_ord_ope +--! @param b public.eql_v3_real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b eql_v3.query_real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_real_ord_ope. +--! @param a eql_v3.query_real_ord_ope +--! @param b public.eql_v3_real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b eql_v3.query_real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_real_ord_ope. +--! @param a eql_v3.query_real_ord_ope +--! @param b public.eql_v3_real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_real_ord_ope. +--! @param a public.eql_v3_real_ord_ope +--! @param b eql_v3.query_real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_real_ord_ope. +--! @param a eql_v3.query_real_ord_ope +--! @param b public.eql_v3_real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + --! @file encrypted_domain/smallint/smallint_ord_ore_functions.sql --! @brief Functions for public.eql_v3_smallint_ord_ore. @@ -6756,6 +7865,33 @@ RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore +--! @param b public.eql_v3_smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_smallint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. --! @param a public.eql_v3_smallint_ord_ore --! @param b jsonpath @@ -6847,56 +7983,403 @@ AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.e LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/smallint/smallint_ord_ope_functions.sql ---! @brief Functions for public.eql_v3_smallint_ord_ope. +--! @file encrypted_domain/smallint/smallint_ord_ore_operators.sql +--! @brief Operators for public.eql_v3_smallint_ord_ore. ---! @brief Index extractor for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_smallint_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) = eql_v3.ord_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/smallint/query_smallint_types.sql +--! @brief Query-operand domains for smallint (index-terms-only, no ciphertext). +--! @note Query-operand domains live in `eql_v3` (not `public`): they are +--! never valid column types, so they don't belong in the column-type +--! namespace, and dropping the EQL-owned schema can never drop an +--! application column. +--! @note Cast a query operand explicitly to its `query_` domain in a predicate +--! (e.g. `WHERE col = $1::eql_v3.query_smallint_eq`). A bare, +--! uncast literal RHS is ambiguous between the `query_` and `jsonb` +--! operator overloads and will not resolve. + +DO $$ +BEGIN + --! @brief Query-operand domain eql_v3.query_smallint_eq (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_smallint_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_smallint_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_smallint_eq IS 'EQL smallint query operand (equality)'; + + --! @brief Query-operand domain eql_v3.query_smallint_ord_ore (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_smallint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_smallint_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_smallint_ord_ore IS 'EQL smallint query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_smallint_ord (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_smallint_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_smallint_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_smallint_ord IS 'EQL smallint query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_smallint_ord_ope (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_smallint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_smallint_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_smallint_ord_ope IS 'EQL smallint query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ope_functions.sql +--! @brief Functions for public.eql_v3_smallint_ord_ope. + +--! @brief Index extractor for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_smallint_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b public.eql_v3_smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$; + +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b public.eql_v3_smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$; --! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. --! @param a jsonb @@ -7146,6 +8629,33 @@ RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b public.eql_v3_smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_smallint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. --! @param a public.eql_v3_smallint_ord_ope --! @param b jsonpath @@ -7536,6 +9046,33 @@ RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord +--! @param b public.eql_v3_smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @param a public.eql_v3_smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @param a jsonb +--! @param b public.eql_v3_smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_smallint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$ +LANGUAGE plpgsql; + --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. --! @param a public.eql_v3_smallint_ord --! @param b jsonpath @@ -7627,3418 +9164,3749 @@ AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.e LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file v3/scalars/smallint/query_smallint_types.sql ---! @brief Query-operand domains for smallint (index-terms-only, no ciphertext). ---! @note Query-operand domains live in `eql_v3` (not `public`): they are ---! never valid column types, so they don't belong in the column-type ---! namespace, and dropping the EQL-owned schema can never drop an ---! application column. ---! @note Cast a query operand explicitly to its `query_` domain in a predicate ---! (e.g. `WHERE col = $1::eql_v3.query_smallint_eq`). A bare, ---! uncast literal RHS is ambiguous between the `query_` and `jsonb` ---! operator overloads and will not resolve. - -DO $$ -BEGIN - --! @brief Query-operand domain eql_v3.query_smallint_eq (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_smallint_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_smallint_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'hm' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_smallint_eq IS 'EQL smallint query operand (equality)'; - - --! @brief Query-operand domain eql_v3.query_smallint_ord_ore (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_smallint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_smallint_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'ob' - AND NOT (VALUE ? 'c') - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_smallint_ord_ore IS 'EQL smallint query operand (equality, ordering)'; - - --! @brief Query-operand domain eql_v3.query_smallint_ord (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_smallint_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_smallint_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'op' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_smallint_ord IS 'EQL smallint query operand (equality, ordering)'; - - --! @brief Query-operand domain eql_v3.query_smallint_ord_ope (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_smallint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_smallint_ord_ope AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'op' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_smallint_ord_ope IS 'EQL smallint query operand (equality, ordering)'; -END -$$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/smallint_eq_functions.sql ---! @brief Functions for public.eql_v3_smallint_eq. +--! @file encrypted_domain/smallint/query_smallint_eq_functions.sql +--! @brief Functions for eql_v3.query_smallint_eq. ---! @brief Index extractor for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Index extractor for eql_v3.query_smallint_eq. +--! @param a eql_v3.query_smallint_eq --! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_smallint_eq) RETURNS eql_v3_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_eq. +--! @brief Operator wrapper for eql_v3.query_smallint_eq. --! @param a public.eql_v3_smallint_eq +--! @param b eql_v3.query_smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b eql_v3.query_smallint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_smallint_eq. +--! @param a eql_v3.query_smallint_eq --! @param b public.eql_v3_smallint_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_eq, b public.eql_v3_smallint_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_eq. +--! @brief Operator wrapper for eql_v3.query_smallint_eq. --! @param a public.eql_v3_smallint_eq ---! @param b jsonb +--! @param b eql_v3.query_smallint_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b eql_v3.query_smallint_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_smallint_eq) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_eq. ---! @param a jsonb +--! @brief Operator wrapper for eql_v3.query_smallint_eq. +--! @param a eql_v3.query_smallint_eq --! @param b public.eql_v3_smallint_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_eq, b public.eql_v3_smallint_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Operator wrapper for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq +--! @file encrypted_domain/smallint/query_smallint_ord_functions.sql +--! @brief Functions for eql_v3.query_smallint_ord. + +--! @brief Index extractor for eql_v3.query_smallint_ord. +--! @param a eql_v3.query_smallint_ord +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_smallint_ord) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_smallint_ord. +--! @param a public.eql_v3_smallint_ord +--! @param b eql_v3.query_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_smallint_ord. +--! @param a eql_v3.query_smallint_ord +--! @param b public.eql_v3_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b jsonb) +CREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_smallint_eq) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_eq. ---! @param a jsonb ---! @param b public.eql_v3_smallint_eq +--! @brief Operator wrapper for eql_v3.query_smallint_ord. +--! @param a public.eql_v3_smallint_ord +--! @param b eql_v3.query_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq +--! @brief Operator wrapper for eql_v3.query_smallint_ord. +--! @param a eql_v3.query_smallint_ord +--! @param b public.eql_v3_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_smallint_ord. +--! @param a public.eql_v3_smallint_ord +--! @param b eql_v3.query_smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_smallint_ord. +--! @param a eql_v3.query_smallint_ord +--! @param b public.eql_v3_smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_smallint_ord. +--! @param a public.eql_v3_smallint_ord +--! @param b eql_v3.query_smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_smallint_ord. +--! @param a eql_v3.query_smallint_ord +--! @param b public.eql_v3_smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_smallint_ord. +--! @param a public.eql_v3_smallint_ord +--! @param b eql_v3.query_smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_smallint_ord. +--! @param a eql_v3.query_smallint_ord +--! @param b public.eql_v3_smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_smallint_ord. +--! @param a public.eql_v3_smallint_ord +--! @param b eql_v3.query_smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_smallint_ord. +--! @param a eql_v3.query_smallint_ord +--! @param b public.eql_v3_smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_functions.sql +--! @brief Functions for public.eql_v3_smallint. + +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint +--! @param b public.eql_v3_smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_smallint. --! @param a jsonb ---! @param b public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_smallint. --! @param a jsonb ---! @param b public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_smallint. --! @param a jsonb ---! @param b public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_smallint. --! @param a jsonb ---! @param b public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_smallint. --! @param a jsonb ---! @param b public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_smallint. --! @param a jsonb ---! @param b public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint +--! @param b public.eql_v3_smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b public.eql_v3_smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a jsonb +--! @param b public.eql_v3_smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint +--! @param b public.eql_v3_smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b public.eql_v3_smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a jsonb +--! @param b public.eql_v3_smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param selector text ---! @return public.eql_v3_smallint_eq -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_eq, selector text) -RETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$ +--! @return public.eql_v3_smallint +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint, selector text) +RETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param selector integer ---! @return public.eql_v3_smallint_eq -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_eq, selector integer) -RETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$ +--! @return public.eql_v3_smallint +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint, selector integer) +RETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_smallint. --! @param a jsonb ---! @param selector public.eql_v3_smallint_eq ---! @return public.eql_v3_smallint_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint_eq) -RETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$ +--! @param selector public.eql_v3_smallint +--! @return public.eql_v3_smallint +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint) +RETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_eq, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_eq, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_smallint. --! @param a jsonb ---! @param selector public.eql_v3_smallint_eq +--! @param selector public.eql_v3_smallint --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint_eq, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint +--! @param b public.eql_v3_smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint, b public.eql_v3_smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a jsonb +--! @param b public.eql_v3_smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_eq, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_eq, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_eq, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint +--! @param b public.eql_v3_smallint --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @param a public.eql_v3_smallint --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_eq, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_smallint. --! @param a jsonb ---! @param b public.eql_v3_smallint_eq +--! @param b public.eql_v3_smallint --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint_eq) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/real_ord_ore_functions.sql ---! @brief Functions for public.eql_v3_real_ord_ore. +--! @file encrypted_domain/smallint/smallint_ord_ope_operators.sql +--! @brief Operators for public.eql_v3_smallint_ord_ope. ---! @brief Index extractor for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_real_ord_ore) -RETURNS eql_v3_internal.ore_block_256 +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_functions.sql +--! @brief Functions for public.eql_v3_date_ord. + +--! @brief Index extractor for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_date_ord) +RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b public.eql_v3_real_ord_ore +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b public.eql_v3_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_date_ord) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @brief Operator wrapper for public.eql_v3_date_ord. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ore +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b public.eql_v3_real_ord_ore +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b public.eql_v3_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_date_ord) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @brief Operator wrapper for public.eql_v3_date_ord. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ore +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b public.eql_v3_real_ord_ore +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b public.eql_v3_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_date_ord) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @brief Operator wrapper for public.eql_v3_date_ord. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ore +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b public.eql_v3_real_ord_ore +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b public.eql_v3_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_date_ord) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @brief Operator wrapper for public.eql_v3_date_ord. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ore +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b public.eql_v3_real_ord_ore +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b public.eql_v3_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_date_ord) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @brief Operator wrapper for public.eql_v3_date_ord. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ore +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b public.eql_v3_real_ord_ore +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b public.eql_v3_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Operator wrapper for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_date_ord) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @brief Operator wrapper for public.eql_v3_date_ord. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ore +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b public.eql_v3_date_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ore +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b public.eql_v3_date_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ore +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param selector text ---! @return public.eql_v3_real_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ore, selector text) -RETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$ +--! @return public.eql_v3_date_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord, selector text) +RETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param selector integer ---! @return public.eql_v3_real_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ore, selector integer) -RETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$ +--! @return public.eql_v3_date_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord, selector integer) +RETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. --! @param a jsonb ---! @param selector public.eql_v3_real_ord_ore ---! @return public.eql_v3_real_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_ord_ore) -RETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$ +--! @param selector public.eql_v3_date_ord +--! @return public.eql_v3_date_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_ord) +RETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ore, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ore, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. --! @param a jsonb ---! @param selector public.eql_v3_real_ord_ore +--! @param selector public.eql_v3_date_ord --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_ord) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b public.eql_v3_date_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord, b public.eql_v3_date_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a jsonb +--! @param b public.eql_v3_date_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_date_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ore, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b public.eql_v3_date_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord, b public.eql_v3_date_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @param a public.eql_v3_date_ord --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ore +--! @param b public.eql_v3_date_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/real_ord_ope_functions.sql ---! @brief Functions for public.eql_v3_real_ord_ope. +--! @file v3/scalars/date/query_date_types.sql +--! @brief Query-operand domains for date (index-terms-only, no ciphertext). +--! @note Query-operand domains live in `eql_v3` (not `public`): they are +--! never valid column types, so they don't belong in the column-type +--! namespace, and dropping the EQL-owned schema can never drop an +--! application column. +--! @note Cast a query operand explicitly to its `query_` domain in a predicate +--! (e.g. `WHERE col = $1::eql_v3.query_date_eq`). A bare, +--! uncast literal RHS is ambiguous between the `query_` and `jsonb` +--! operator overloads and will not resolve. ---! @brief Index extractor for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +DO $$ +BEGIN + --! @brief Query-operand domain eql_v3.query_date_eq (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_date_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_date_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_date_eq IS 'EQL date query operand (equality)'; + + --! @brief Query-operand domain eql_v3.query_date_ord_ore (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_date_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_date_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_date_ord_ore IS 'EQL date query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_date_ord (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_date_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_date_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_date_ord IS 'EQL date query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_date_ord_ope (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_date_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_date_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_date_ord_ope IS 'EQL date query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/query_date_ord_functions.sql +--! @brief Functions for eql_v3.query_date_ord. + +--! @brief Index extractor for eql_v3.query_date_ord. +--! @param a eql_v3.query_date_ord --! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_date_ord) RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b public.eql_v3_real_ord_ope +--! @brief Operator wrapper for eql_v3.query_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b eql_v3.query_date_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b eql_v3.query_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_date_ord. +--! @param a eql_v3.query_date_ord +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord, b public.eql_v3_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_real_ord_ope +--! @brief Operator wrapper for eql_v3.query_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b eql_v3.query_date_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b eql_v3.query_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b public.eql_v3_real_ord_ope +--! @brief Operator wrapper for eql_v3.query_date_ord. +--! @param a eql_v3.query_date_ord +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord, b public.eql_v3_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b eql_v3.query_date_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b eql_v3.query_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_real_ord_ope +--! @brief Operator wrapper for eql_v3.query_date_ord. +--! @param a eql_v3.query_date_ord +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord, b public.eql_v3_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b public.eql_v3_real_ord_ope +--! @brief Operator wrapper for eql_v3.query_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b eql_v3.query_date_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b eql_v3.query_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_date_ord. +--! @param a eql_v3.query_date_ord +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord, b public.eql_v3_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_real_ord_ope +--! @brief Operator wrapper for eql_v3.query_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b eql_v3.query_date_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b eql_v3.query_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b public.eql_v3_real_ord_ope +--! @brief Operator wrapper for eql_v3.query_date_ord. +--! @param a eql_v3.query_date_ord +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord, b public.eql_v3_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_date_ord. +--! @param a public.eql_v3_date_ord +--! @param b eql_v3.query_date_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b eql_v3.query_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_real_ord_ope +--! @brief Operator wrapper for eql_v3.query_date_ord. +--! @param a eql_v3.query_date_ord +--! @param b public.eql_v3_date_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord, b public.eql_v3_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b public.eql_v3_real_ord_ope +--! @file encrypted_domain/date/date_ord_ore_functions.sql +--! @brief Functions for public.eql_v3_date_ord_ore. + +--! @brief Index extractor for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_date_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b public.eql_v3_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ope +--! @param b public.eql_v3_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b public.eql_v3_real_ord_ope +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b public.eql_v3_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ope +--! @param b public.eql_v3_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) <> eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b public.eql_v3_real_ord_ope +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b public.eql_v3_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$; + +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ope +--! @param b public.eql_v3_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) < eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b public.eql_v3_date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$; + +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) <= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b public.eql_v3_date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$; + +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) > eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b public.eql_v3_date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$; + +--! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) >= eql_v3.ord_term_ore(b) $$; + +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b public.eql_v3_date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b public.eql_v3_date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ope +--! @param b public.eql_v3_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param selector text ---! @return public.eql_v3_real_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ope, selector text) -RETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$ +--! @return public.eql_v3_date_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ore, selector text) +RETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param selector integer ---! @return public.eql_v3_real_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ope, selector integer) -RETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$ +--! @return public.eql_v3_date_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ore, selector integer) +RETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. --! @param a jsonb ---! @param selector public.eql_v3_real_ord_ope ---! @return public.eql_v3_real_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_ord_ope) -RETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$ +--! @param selector public.eql_v3_date_ord_ore +--! @return public.eql_v3_date_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_ord_ore) +RETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ope, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ope, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. --! @param a jsonb ---! @param selector public.eql_v3_real_ord_ope +--! @param selector public.eql_v3_date_ord_ore --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_ord_ope, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b public.eql_v3_date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_date_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ope, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ope, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore +--! @param b public.eql_v3_date_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @param a public.eql_v3_date_ord_ore --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ope +--! @param b public.eql_v3_date_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_ord_ope) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/real_ord_functions.sql ---! @brief Functions for public.eql_v3_real_ord. +--! @file encrypted_domain/date/date_ord_ope_functions.sql +--! @brief Functions for public.eql_v3_date_ord_ope. ---! @brief Index extractor for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Index extractor for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_date_ord_ope) RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b public.eql_v3_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_real_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real_ord +--! @param b public.eql_v3_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b public.eql_v3_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_real_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real_ord +--! @param b public.eql_v3_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b public.eql_v3_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_real_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real_ord +--! @param b public.eql_v3_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b public.eql_v3_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_real_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real_ord +--! @param b public.eql_v3_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b public.eql_v3_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_real_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real_ord +--! @param b public.eql_v3_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b public.eql_v3_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_real_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. +--! @brief Operator wrapper for public.eql_v3_date_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real_ord +--! @param b public.eql_v3_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b public.eql_v3_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real_ord +--! @param b public.eql_v3_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b public.eql_v3_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real_ord +--! @param b public.eql_v3_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param selector text ---! @return public.eql_v3_real_ord -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord, selector text) -RETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$ +--! @return public.eql_v3_date_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ope, selector text) +RETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param selector integer ---! @return public.eql_v3_real_ord -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord, selector integer) -RETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$ +--! @return public.eql_v3_date_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ope, selector integer) +RETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. --! @param a jsonb ---! @param selector public.eql_v3_real_ord ---! @return public.eql_v3_real_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_ord) -RETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$ +--! @param selector public.eql_v3_date_ord_ope +--! @return public.eql_v3_date_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_ord_ope) +RETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. --! @param a jsonb ---! @param selector public.eql_v3_real_ord +--! @param selector public.eql_v3_date_ord_ope --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_ord) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_ord, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b public.eql_v3_date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_date_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope +--! @param b public.eql_v3_date_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @param a public.eql_v3_date_ord_ope --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real_ord +--! @param b public.eql_v3_date_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file v3/scalars/real/query_real_types.sql ---! @brief Query-operand domains for real (index-terms-only, no ciphertext). ---! @note Query-operand domains live in `eql_v3` (not `public`): they are ---! never valid column types, so they don't belong in the column-type ---! namespace, and dropping the EQL-owned schema can never drop an ---! application column. ---! @note Cast a query operand explicitly to its `query_` domain in a predicate ---! (e.g. `WHERE col = $1::eql_v3.query_real_eq`). A bare, ---! uncast literal RHS is ambiguous between the `query_` and `jsonb` ---! operator overloads and will not resolve. - -DO $$ -BEGIN - --! @brief Query-operand domain eql_v3.query_real_eq (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_real_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_real_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'hm' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_real_eq IS 'EQL real query operand (equality)'; - - --! @brief Query-operand domain eql_v3.query_real_ord_ore (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_real_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_real_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'ob' - AND NOT (VALUE ? 'c') - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_real_ord_ore IS 'EQL real query operand (equality, ordering)'; - - --! @brief Query-operand domain eql_v3.query_real_ord (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_real_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_real_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'op' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_real_ord IS 'EQL real query operand (equality, ordering)'; - - --! @brief Query-operand domain eql_v3.query_real_ord_ope (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_real_ord_ope' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_real_ord_ope AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'op' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_real_ord_ope IS 'EQL real query operand (equality, ordering)'; -END -$$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/real/real_eq_functions.sql ---! @brief Functions for public.eql_v3_real_eq. +--! @file encrypted_domain/date/date_eq_functions.sql +--! @brief Functions for public.eql_v3_date_eq. ---! @brief Index extractor for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Index extractor for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_real_eq) +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_date_eq) RETURNS eql_v3_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq +--! @brief Operator wrapper for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b public.eql_v3_date_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Operator wrapper for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_real_eq) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_date_eq) $$; ---! @brief Operator wrapper for public.eql_v3_real_eq. +--! @brief Operator wrapper for public.eql_v3_date_eq. --! @param a jsonb ---! @param b public.eql_v3_real_eq +--! @param b public.eql_v3_date_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_eq) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq +--! @brief Operator wrapper for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b public.eql_v3_date_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Operator wrapper for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_real_eq) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_date_eq) $$; ---! @brief Operator wrapper for public.eql_v3_real_eq. +--! @brief Operator wrapper for public.eql_v3_date_eq. --! @param a jsonb ---! @param b public.eql_v3_real_eq +--! @param b public.eql_v3_date_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_eq) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) <> eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b public.eql_v3_date_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. --! @param a jsonb ---! @param b public.eql_v3_real_eq +--! @param b public.eql_v3_date_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real_eq) +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b public.eql_v3_date_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. --! @param a jsonb ---! @param b public.eql_v3_real_eq +--! @param b public.eql_v3_date_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real_eq) +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b public.eql_v3_date_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. --! @param a jsonb ---! @param b public.eql_v3_real_eq +--! @param b public.eql_v3_date_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real_eq) +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b public.eql_v3_date_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. --! @param a jsonb ---! @param b public.eql_v3_real_eq +--! @param b public.eql_v3_date_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real_eq) +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b public.eql_v3_date_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. --! @param a jsonb ---! @param b public.eql_v3_real_eq +--! @param b public.eql_v3_date_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_eq) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b public.eql_v3_date_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. --! @param a jsonb ---! @param b public.eql_v3_real_eq +--! @param b public.eql_v3_date_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_eq) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param selector text ---! @return public.eql_v3_real_eq -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_eq, selector text) -RETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$ +--! @return public.eql_v3_date_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_eq, selector text) +RETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param selector integer ---! @return public.eql_v3_real_eq -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_eq, selector integer) -RETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$ +--! @return public.eql_v3_date_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_eq, selector integer) +RETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. --! @param a jsonb ---! @param selector public.eql_v3_real_eq ---! @return public.eql_v3_real_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_eq) -RETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$ +--! @param selector public.eql_v3_date_eq +--! @return public.eql_v3_date_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_eq) +RETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_eq, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_eq, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. --! @param a jsonb ---! @param selector public.eql_v3_real_eq +--! @param selector public.eql_v3_date_eq --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_eq) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_eq) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_eq, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b public.eql_v3_date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_eq, b public.eql_v3_date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a jsonb +--! @param b public.eql_v3_date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_eq, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_eq, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_eq, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b public.eql_v3_date_eq --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @param a public.eql_v3_date_eq --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_eq, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. --! @param a jsonb ---! @param b public.eql_v3_real_eq +--! @param b public.eql_v3_date_eq --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_eq) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file v3/scalars/numeric/query_numeric_types.sql ---! @brief Query-operand domains for numeric (index-terms-only, no ciphertext). ---! @note Query-operand domains live in `eql_v3` (not `public`): they are ---! never valid column types, so they don't belong in the column-type ---! namespace, and dropping the EQL-owned schema can never drop an ---! application column. ---! @note Cast a query operand explicitly to its `query_` domain in a predicate ---! (e.g. `WHERE col = $1::eql_v3.query_numeric_eq`). A bare, ---! uncast literal RHS is ambiguous between the `query_` and `jsonb` ---! operator overloads and will not resolve. - -DO $$ -BEGIN - --! @brief Query-operand domain eql_v3.query_numeric_eq (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_numeric_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_numeric_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'hm' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_numeric_eq IS 'EQL numeric query operand (equality)'; - - --! @brief Query-operand domain eql_v3.query_numeric_ord_ore (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_numeric_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_numeric_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'ob' - AND NOT (VALUE ? 'c') - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_numeric_ord_ore IS 'EQL numeric query operand (equality, ordering)'; - - --! @brief Query-operand domain eql_v3.query_numeric_ord (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_numeric_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_numeric_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'op' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_numeric_ord IS 'EQL numeric query operand (equality, ordering)'; - - --! @brief Query-operand domain eql_v3.query_numeric_ord_ope (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_numeric_ord_ope' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_numeric_ord_ope AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'op' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_numeric_ord_ope IS 'EQL numeric query operand (equality, ordering)'; -END -$$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_ord_ore_functions.sql ---! @brief Functions for public.eql_v3_numeric_ord_ore. - ---! @brief Index extractor for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_numeric_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +--! @file encrypted_domain/date/date_functions.sql +--! @brief Functions for public.eql_v3_date. ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b public.eql_v3_date --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$; +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_date. --! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_date --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) = eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b public.eql_v3_date --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$; +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_date. --! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_date --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) <> eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b public.eql_v3_date --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_date. --! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_date --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) < eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b public.eql_v3_date --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_date. --! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_date --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) <= eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b public.eql_v3_date --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_date. --! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_date --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) > eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b public.eql_v3_date --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_date. --! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_date --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) >= eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b public.eql_v3_date --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_date. --! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_date --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b public.eql_v3_date --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_date. --! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_date --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param selector text ---! @return public.eql_v3_numeric_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ore, selector text) -RETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$ +--! @return public.eql_v3_date +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date, selector text) +RETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param selector integer ---! @return public.eql_v3_numeric_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ore, selector integer) -RETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$ +--! @return public.eql_v3_date +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date, selector integer) +RETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_date. --! @param a jsonb ---! @param selector public.eql_v3_numeric_ord_ore ---! @return public.eql_v3_numeric_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric_ord_ore) -RETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$ +--! @param selector public.eql_v3_date +--! @return public.eql_v3_date +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date) +RETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ore, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ore, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_date. --! @param a jsonb ---! @param selector public.eql_v3_numeric_ord_ore +--! @param selector public.eql_v3_date --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric_ord_ore) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b public.eql_v3_date +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a jsonb +--! @param b public.eql_v3_date +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ore, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date +--! @param b public.eql_v3_date --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date, b public.eql_v3_date) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! @param a public.eql_v3_date --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_date. --! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_date --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/numeric/numeric_ord_functions.sql ---! @brief Functions for public.eql_v3_numeric_ord. +--! @file encrypted_domain/date/date_ord_ore_operators.sql +--! @brief Operators for public.eql_v3_date_ord_ore. ---! @brief Index extractor for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_numeric_ord) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) = eql_v3.ord_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) <> eql_v3.ord_term(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) < eql_v3.ord_term(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) > eql_v3.ord_term(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) >= eql_v3.ord_term(b) $$; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param selector text ---! @return public.eql_v3_numeric_ord -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord, selector text) -RETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param selector integer ---! @return public.eql_v3_numeric_ord -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord, selector integer) -RETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param selector public.eql_v3_numeric_ord ---! @return public.eql_v3_numeric_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric_ord) -RETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param selector public.eql_v3_numeric_ord ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric_ord) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric_ord, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric_ord, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonpath +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric_ord, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonpath +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric_ord) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[] +); ---! @file encrypted_domain/numeric/numeric_ord_ope_functions.sql ---! @brief Functions for public.eql_v3_numeric_ord_ope. +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore +); ---! @brief Index extractor for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_numeric_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$; +--! @file encrypted_domain/date/date_ord_ope_operators.sql +--! @brief Operators for public.eql_v3_date_ord_ope. ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) = eql_v3.ord_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) <> eql_v3.ord_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) < eql_v3.ord_term(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) > eql_v3.ord_term(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) >= eql_v3.ord_term(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param selector text ---! @return public.eql_v3_numeric_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ope, selector text) -RETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param selector integer ---! @return public.eql_v3_numeric_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ope, selector integer) -RETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_numeric_ord_ope ---! @return public.eql_v3_numeric_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric_ord_ope) -RETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ope, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ope, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_numeric_ord_ope ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric_ord_ope) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric_ord_ope, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric_ord_ope, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ope, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonpath +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric_ord_ope, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ope, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ope, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonpath +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ope, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/numeric/query_numeric_types.sql +--! @brief Query-operand domains for numeric (index-terms-only, no ciphertext). +--! @note Query-operand domains live in `eql_v3` (not `public`): they are +--! never valid column types, so they don't belong in the column-type +--! namespace, and dropping the EQL-owned schema can never drop an +--! application column. +--! @note Cast a query operand explicitly to its `query_` domain in a predicate +--! (e.g. `WHERE col = $1::eql_v3.query_numeric_eq`). A bare, +--! uncast literal RHS is ambiguous between the `query_` and `jsonb` +--! operator overloads and will not resolve. + +DO $$ +BEGIN + --! @brief Query-operand domain eql_v3.query_numeric_eq (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_numeric_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_numeric_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_numeric_eq IS 'EQL numeric query operand (equality)'; + + --! @brief Query-operand domain eql_v3.query_numeric_ord_ore (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_numeric_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_numeric_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_numeric_ord_ore IS 'EQL numeric query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_numeric_ord (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_numeric_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_numeric_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_numeric_ord IS 'EQL numeric query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_numeric_ord_ope (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_numeric_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_numeric_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_numeric_ord_ope IS 'EQL numeric query operand (equality, ordering)'; +END +$$; -- AUTOMATICALLY GENERATED FILE. --! @file encrypted_domain/numeric/numeric_eq_functions.sql @@ -11352,6 +13220,33 @@ RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq +--! @param b public.eql_v3_numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @param a public.eql_v3_numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @param a jsonb +--! @param b public.eql_v3_numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$ +LANGUAGE plpgsql; + --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. --! @param a public.eql_v3_numeric_eq --! @param b jsonpath @@ -11443,2148 +13338,2637 @@ AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.e LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file v3/scalars/integer/query_integer_types.sql ---! @brief Query-operand domains for integer (index-terms-only, no ciphertext). ---! @note Query-operand domains live in `eql_v3` (not `public`): they are ---! never valid column types, so they don't belong in the column-type ---! namespace, and dropping the EQL-owned schema can never drop an ---! application column. ---! @note Cast a query operand explicitly to its `query_` domain in a predicate ---! (e.g. `WHERE col = $1::eql_v3.query_integer_eq`). A bare, ---! uncast literal RHS is ambiguous between the `query_` and `jsonb` ---! operator overloads and will not resolve. +--! @file encrypted_domain/numeric/numeric_ord_functions.sql +--! @brief Functions for public.eql_v3_numeric_ord. -DO $$ -BEGIN - --! @brief Query-operand domain eql_v3.query_integer_eq (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_integer_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_integer_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'hm' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; +--! @brief Index extractor for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_numeric_ord) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; - COMMENT ON DOMAIN eql_v3.query_integer_eq IS 'EQL integer query operand (equality)'; +--! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b public.eql_v3_numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - --! @brief Query-operand domain eql_v3.query_integer_ord_ore (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_integer_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_integer_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'ob' - AND NOT (VALUE ? 'c') - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_integer_ord_ore IS 'EQL integer query operand (equality, ordering)'; - - --! @brief Query-operand domain eql_v3.query_integer_ord (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_integer_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_integer_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'op' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_integer_ord IS 'EQL integer query operand (equality, ordering)'; - - --! @brief Query-operand domain eql_v3.query_integer_ord_ope (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_integer_ord_ope' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_integer_ord_ope AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'op' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; - - COMMENT ON DOMAIN eql_v3.query_integer_ord_ope IS 'EQL integer query operand (equality, ordering)'; -END -$$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/integer/integer_ord_ore_functions.sql ---! @brief Functions for public.eql_v3_integer_ord_ore. - ---! @brief Index extractor for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_integer_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @brief Operator wrapper for public.eql_v3_numeric_ord. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @brief Operator wrapper for public.eql_v3_numeric_ord. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @brief Operator wrapper for public.eql_v3_numeric_ord. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @brief Operator wrapper for public.eql_v3_numeric_ord. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @brief Operator wrapper for public.eql_v3_numeric_ord. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @brief Operator wrapper for public.eql_v3_numeric_ord. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param selector text ---! @return public.eql_v3_integer_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ore, selector text) -RETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$ +--! @return public.eql_v3_numeric_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord, selector text) +RETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param selector integer ---! @return public.eql_v3_integer_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ore, selector integer) -RETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$ +--! @return public.eql_v3_numeric_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord, selector integer) +RETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. --! @param a jsonb ---! @param selector public.eql_v3_integer_ord_ore ---! @return public.eql_v3_integer_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_ord_ore) -RETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$ +--! @param selector public.eql_v3_numeric_ord +--! @return public.eql_v3_numeric_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric_ord) +RETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ore, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ore, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. --! @param a jsonb ---! @param selector public.eql_v3_integer_ord_ore +--! @param selector public.eql_v3_numeric_ord --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_ord_ore) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric_ord) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b public.eql_v3_numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a jsonb +--! @param b public.eql_v3_numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_numeric_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ore, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b public.eql_v3_numeric_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @param a public.eql_v3_numeric_ord --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_numeric_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/integer/integer_ord_functions.sql ---! @brief Functions for public.eql_v3_integer_ord. +--! @file encrypted_domain/numeric/query_numeric_ord_functions.sql +--! @brief Functions for eql_v3.query_numeric_ord. ---! @brief Index extractor for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Index extractor for eql_v3.query_numeric_ord. +--! @param a eql_v3.query_numeric_ord --! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_numeric_ord) RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for eql_v3.query_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b eql_v3.query_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_numeric_ord. +--! @param a eql_v3.query_numeric_ord +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b jsonb) +CREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_integer_ord) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a jsonb ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for eql_v3.query_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b eql_v3.query_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for eql_v3.query_numeric_ord. +--! @param a eql_v3.query_numeric_ord +--! @param b public.eql_v3_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Operator wrapper for eql_v3.query_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b eql_v3.query_numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord. +--! @param a eql_v3.query_numeric_ord +--! @param b public.eql_v3_numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b eql_v3.query_numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord. +--! @param a eql_v3.query_numeric_ord +--! @param b public.eql_v3_numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b eql_v3.query_numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord. +--! @param a eql_v3.query_numeric_ord +--! @param b public.eql_v3_numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord. +--! @param a public.eql_v3_numeric_ord +--! @param b eql_v3.query_numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord. +--! @param a eql_v3.query_numeric_ord +--! @param b public.eql_v3_numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ore_functions.sql +--! @brief Functions for public.eql_v3_numeric_ord_ore. + +--! @brief Index extractor for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_numeric_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_integer_ord) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_integer_ord +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_integer_ord) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_integer_ord +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) <> eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_integer_ord) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_integer_ord +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) < eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_integer_ord) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_integer_ord +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) <= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_integer_ord) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_integer_ord +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) > eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$; + +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) >= eql_v3.ord_term_ore(b) $$; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_integer_ord +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_integer_ord +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param selector text ---! @return public.eql_v3_integer_ord -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord, selector text) -RETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$ +--! @return public.eql_v3_numeric_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ore, selector text) +RETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param selector integer ---! @return public.eql_v3_integer_ord -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord, selector integer) -RETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$ +--! @return public.eql_v3_numeric_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ore, selector integer) +RETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. --! @param a jsonb ---! @param selector public.eql_v3_integer_ord ---! @return public.eql_v3_integer_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_ord) -RETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$ +--! @param selector public.eql_v3_numeric_ord_ore +--! @return public.eql_v3_numeric_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric_ord_ore) +RETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. --! @param a jsonb ---! @param selector public.eql_v3_integer_ord +--! @param selector public.eql_v3_numeric_ord_ore --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_ord, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_numeric_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_integer_ord +--! @param b public.eql_v3_numeric_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/integer/integer_ord_ope_functions.sql ---! @brief Functions for public.eql_v3_integer_ord_ope. +--! @file encrypted_domain/numeric/query_numeric_ord_ore_functions.sql +--! @brief Functions for eql_v3.query_numeric_ord_ore. ---! @brief Index extractor for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_integer_ord_ope) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for eql_v3.query_numeric_ord_ore. +--! @param a eql_v3.query_numeric_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_numeric_ord_ore) +RETURNS eql_v3_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b eql_v3.query_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. +--! @param a eql_v3.query_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b eql_v3.query_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. +--! @param a eql_v3.query_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b eql_v3.query_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. +--! @param a eql_v3.query_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b eql_v3.query_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. +--! @param a eql_v3.query_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b eql_v3.query_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. +--! @param a eql_v3.query_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. +--! @param a public.eql_v3_numeric_ord_ore +--! @param b eql_v3.query_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. +--! @param a eql_v3.query_numeric_ord_ore +--! @param b public.eql_v3_numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ope_functions.sql +--! @brief Functions for public.eql_v3_numeric_ord_ope. + +--! @brief Index extractor for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_numeric_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$; + +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param selector text ---! @return public.eql_v3_integer_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ope, selector text) -RETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$ +--! @return public.eql_v3_numeric_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ope, selector text) +RETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param selector integer ---! @return public.eql_v3_integer_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ope, selector integer) -RETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$ +--! @return public.eql_v3_numeric_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ope, selector integer) +RETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. --! @param a jsonb ---! @param selector public.eql_v3_integer_ord_ope ---! @return public.eql_v3_integer_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_ord_ope) -RETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$ +--! @param selector public.eql_v3_numeric_ord_ope +--! @return public.eql_v3_numeric_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric_ord_ope) +RETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ope, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ope, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. --! @param a jsonb ---! @param selector public.eql_v3_integer_ord_ope +--! @param selector public.eql_v3_numeric_ord_ope --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_ord_ope, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_numeric_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ope, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ope, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/integer/integer_eq_functions.sql ---! @brief Functions for public.eql_v3_integer_eq. +--! @file encrypted_domain/numeric/query_numeric_ord_ope_functions.sql +--! @brief Functions for eql_v3.query_numeric_ord_ope. ---! @brief Index extractor for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_integer_eq) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for eql_v3.query_numeric_ord_ope. +--! @param a eql_v3.query_numeric_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_numeric_ord_ope) +RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b eql_v3.query_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. +--! @param a eql_v3.query_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b jsonb) +CREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_integer_eq) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b eql_v3.query_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_eq) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. +--! @param a eql_v3.query_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) +CREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b eql_v3.query_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_integer_eq) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. +--! @param a eql_v3.query_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_eq) +CREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b eql_v3.query_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. +--! @param a eql_v3.query_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b eql_v3.query_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. +--! @param a eql_v3.query_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. +--! @param a public.eql_v3_numeric_ord_ope +--! @param b eql_v3.query_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq +--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. +--! @param a eql_v3.query_numeric_ord_ope +--! @param b public.eql_v3_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/numeric/numeric_ord_ore_operators.sql +--! @brief Operators for public.eql_v3_numeric_ord_ore. ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param selector text ---! @return public.eql_v3_integer_eq -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_eq, selector text) -RETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param selector integer ---! @return public.eql_v3_integer_eq -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_eq, selector integer) -RETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param selector public.eql_v3_integer_eq ---! @return public.eql_v3_integer_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_eq) -RETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_eq, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_eq, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param selector public.eql_v3_integer_eq ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_eq) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_eq, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_eq, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_eq, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_eq, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_eq, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore +); ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore +); -- AUTOMATICALLY GENERATED FILE. ---! @file v3/scalars/double/query_double_types.sql ---! @brief Query-operand domains for double (index-terms-only, no ciphertext). ---! @note Query-operand domains live in `eql_v3` (not `public`): they are ---! never valid column types, so they don't belong in the column-type ---! namespace, and dropping the EQL-owned schema can never drop an ---! application column. ---! @note Cast a query operand explicitly to its `query_` domain in a predicate ---! (e.g. `WHERE col = $1::eql_v3.query_double_eq`). A bare, ---! uncast literal RHS is ambiguous between the `query_` and `jsonb` ---! operator overloads and will not resolve. +--! @file encrypted_domain/numeric/numeric_ord_ope_operators.sql +--! @brief Operators for public.eql_v3_numeric_ord_ope. -DO $$ -BEGIN - --! @brief Query-operand domain eql_v3.query_double_eq (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_double_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_double_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'hm' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - COMMENT ON DOMAIN eql_v3.query_double_eq IS 'EQL double query operand (equality)'; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - --! @brief Query-operand domain eql_v3.query_double_ord_ore (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_double_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_double_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'ob' - AND NOT (VALUE ? 'c') - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - COMMENT ON DOMAIN eql_v3.query_double_ord_ore IS 'EQL double query operand (equality, ordering)'; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); - --! @brief Query-operand domain eql_v3.query_double_ord (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_double_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_double_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'op' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); - COMMENT ON DOMAIN eql_v3.query_double_ord IS 'EQL double query operand (equality, ordering)'; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); - --! @brief Query-operand domain eql_v3.query_double_ord_ope (term-only; no `c`). +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/json/json_types.sql +--! @brief Encrypted-domain types for json. + +DO $$ +BEGIN + --! @brief Encrypted domain public.eql_v3_json. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_double_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'eql_v3_json' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_double_ord_ope AS jsonb + CREATE DOMAIN public.eql_v3_json AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' - AND VALUE ? 'op' - AND NOT (VALUE ? 'c') + AND VALUE ? 'c' AND VALUE->>'v' = '3' ); END IF; - COMMENT ON DOMAIN eql_v3.query_double_ord_ope IS 'EQL double query operand (equality, ordering)'; + COMMENT ON DOMAIN public.eql_v3_json IS 'EQL encrypted json (storage only)'; END $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/double_ord_ore_functions.sql ---! @brief Functions for public.eql_v3_double_ord_ore. - ---! @brief Index extractor for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_double_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +--! @file encrypted_domain/json/json_functions.sql +--! @brief Functions for public.eql_v3_json. ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b public.eql_v3_json --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$; +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_json. --! @param a jsonb ---! @param b public.eql_v3_double_ord_ore +--! @param b public.eql_v3_json --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) = eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b public.eql_v3_json --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$; +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_json. --! @param a jsonb ---! @param b public.eql_v3_double_ord_ore +--! @param b public.eql_v3_json --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) <> eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b public.eql_v3_json --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_json. --! @param a jsonb ---! @param b public.eql_v3_double_ord_ore +--! @param b public.eql_v3_json --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) < eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b public.eql_v3_json --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_json. --! @param a jsonb ---! @param b public.eql_v3_double_ord_ore +--! @param b public.eql_v3_json --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) <= eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b public.eql_v3_json --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_json. --! @param a jsonb ---! @param b public.eql_v3_double_ord_ore +--! @param b public.eql_v3_json --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) > eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b public.eql_v3_json --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_json. --! @param a jsonb ---! @param b public.eql_v3_double_ord_ore +--! @param b public.eql_v3_json --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) >= eql_v3.ord_term_ore(b) $$; +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b public.eql_v3_json --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_json. --! @param a jsonb ---! @param b public.eql_v3_double_ord_ore +--! @param b public.eql_v3_json --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b public.eql_v3_json --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_json. --! @param a jsonb ---! @param b public.eql_v3_double_ord_ore +--! @param b public.eql_v3_json --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param selector text ---! @return public.eql_v3_double_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord_ore, selector text) -RETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$ +--! @return public.eql_v3_json +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_json, selector text) +RETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param selector integer ---! @return public.eql_v3_double_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord_ore, selector integer) -RETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$ +--! @return public.eql_v3_json +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_json, selector integer) +RETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_json. --! @param a jsonb ---! @param selector public.eql_v3_double_ord_ore ---! @return public.eql_v3_double_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double_ord_ore) -RETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$ +--! @param selector public.eql_v3_json +--! @return public.eql_v3_json +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_json) +RETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord_ore, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_json, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord_ore, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_json, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_json. --! @param a jsonb ---! @param selector public.eql_v3_double_ord_ore +--! @param selector public.eql_v3_json --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double_ord_ore) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_json) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_json, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_json, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_json, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_json, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b public.eql_v3_json +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_json, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_json, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a jsonb +--! @param b public.eql_v3_json +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_json, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_json, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_json, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_json, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ore, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_json, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_json, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_json, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json +--! @param b public.eql_v3_json --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_json, b public.eql_v3_json) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! @param a public.eql_v3_json --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_json, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_json. --! @param a jsonb ---! @param b public.eql_v3_double_ord_ore +--! @param b public.eql_v3_json --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_json) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. +--! @file v3/scalars/double/query_double_types.sql +--! @brief Query-operand domains for double (index-terms-only, no ciphertext). +--! @note Query-operand domains live in `eql_v3` (not `public`): they are +--! never valid column types, so they don't belong in the column-type +--! namespace, and dropping the EQL-owned schema can never drop an +--! application column. +--! @note Cast a query operand explicitly to its `query_` domain in a predicate +--! (e.g. `WHERE col = $1::eql_v3.query_double_eq`). A bare, +--! uncast literal RHS is ambiguous between the `query_` and `jsonb` +--! operator overloads and will not resolve. + +DO $$ +BEGIN + --! @brief Query-operand domain eql_v3.query_double_eq (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_double_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_double_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_double_eq IS 'EQL double query operand (equality)'; + + --! @brief Query-operand domain eql_v3.query_double_ord_ore (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_double_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_double_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_double_ord_ore IS 'EQL double query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_double_ord (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_double_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_double_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_double_ord IS 'EQL double query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_double_ord_ope (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_double_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_double_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_double_ord_ope IS 'EQL double query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + --! @file encrypted_domain/double/double_ord_functions.sql --! @brief Functions for public.eql_v3_double_ord. @@ -13884,6 +16268,33 @@ RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; +--! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord, b public.eql_v3_double_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @param a jsonb +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_double_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$ +LANGUAGE plpgsql; + --! @brief Unsupported operator blocker for public.eql_v3_double_ord. --! @param a public.eql_v3_double_ord --! @param b jsonpath @@ -13975,6 +16386,423 @@ AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.e LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. +--! @file encrypted_domain/double/double_ord_ore_functions.sql +--! @brief Functions for public.eql_v3_double_ord_ore. + +--! @brief Index extractor for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_double_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$; + +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) = eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$; + +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) <> eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$; + +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) < eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$; + +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) <= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$; + +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) > eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$; + +--! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) >= eql_v3.ord_term_ore(b) $$; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param selector text +--! @return public.eql_v3_double_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord_ore, selector text) +RETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param selector integer +--! @return public.eql_v3_double_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord_ore, selector integer) +RETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a jsonb +--! @param selector public.eql_v3_double_ord_ore +--! @return public.eql_v3_double_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double_ord_ore) +RETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a jsonb +--! @param selector public.eql_v3_double_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_double_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_double_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + --! @file encrypted_domain/double/double_ord_ope_functions.sql --! @brief Functions for public.eql_v3_double_ord_ope. @@ -14274,6 +17102,33 @@ RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_double_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$ +LANGUAGE plpgsql; + --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. --! @param a public.eql_v3_double_ord_ope --! @param b jsonpath @@ -14365,15386 +17220,16679 @@ AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.e LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/double_eq_functions.sql ---! @brief Functions for public.eql_v3_double_eq. - ---! @brief Index extractor for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_double_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +--! @file encrypted_domain/double/double_ord_operators.sql +--! @brief Operators for public.eql_v3_double_ord. ---! @brief Operator wrapper for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b public.eql_v3_double_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_double_eq) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) = eql_v3.eq_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b public.eql_v3_double_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_double_eq) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b public.eql_v3_double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b public.eql_v3_double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b public.eql_v3_double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b public.eql_v3_double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b public.eql_v3_double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b public.eql_v3_double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param selector text ---! @return public.eql_v3_double_eq -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_eq, selector text) -RETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param selector integer ---! @return public.eql_v3_double_eq -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_eq, selector integer) -RETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param selector public.eql_v3_double_eq ---! @return public.eql_v3_double_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double_eq) -RETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_eq, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_eq, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param selector public.eql_v3_double_eq ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double_eq) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double_eq, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double_eq, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonpath +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_eq, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double_eq, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_eq, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonpath +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_eq, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double_eq, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_eq, b public.eql_v3_double_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_eq, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double_eq) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[] +); ---! @file v3/scalars/date/query_date_types.sql ---! @brief Query-operand domains for date (index-terms-only, no ciphertext). ---! @note Query-operand domains live in `eql_v3` (not `public`): they are ---! never valid column types, so they don't belong in the column-type ---! namespace, and dropping the EQL-owned schema can never drop an ---! application column. ---! @note Cast a query operand explicitly to its `query_` domain in a predicate ---! (e.g. `WHERE col = $1::eql_v3.query_date_eq`). A bare, ---! uncast literal RHS is ambiguous between the `query_` and `jsonb` ---! operator overloads and will not resolve. +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord +); -DO $$ -BEGIN - --! @brief Query-operand domain eql_v3.query_date_eq (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_date_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_date_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'hm' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb +); - COMMENT ON DOMAIN eql_v3.query_date_eq IS 'EQL date query operand (equality)'; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord +); +-- AUTOMATICALLY GENERATED FILE. - --! @brief Query-operand domain eql_v3.query_date_ord_ore (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_date_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_date_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'ob' - AND NOT (VALUE ? 'c') - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; +--! @file encrypted_domain/double/double_ord_ope_operators.sql +--! @brief Operators for public.eql_v3_double_ord_ope. - COMMENT ON DOMAIN eql_v3.query_date_ord_ore IS 'EQL date query operand (equality, ordering)'; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - --! @brief Query-operand domain eql_v3.query_date_ord (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_date_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_date_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'op' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - COMMENT ON DOMAIN eql_v3.query_date_ord IS 'EQL date query operand (equality, ordering)'; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - --! @brief Query-operand domain eql_v3.query_date_ord_ope (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_date_ord_ope' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_date_ord_ope AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'op' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); - COMMENT ON DOMAIN eql_v3.query_date_ord_ope IS 'EQL date query operand (equality, ordering)'; -END -$$; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @file encrypted_domain/date/date_ord_ore_functions.sql ---! @brief Functions for public.eql_v3_date_ord_ore. +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Index extractor for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_date_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b public.eql_v3_date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) = eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b public.eql_v3_date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) <> eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b public.eql_v3_date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) < eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b public.eql_v3_date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) <= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope +); ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b public.eql_v3_date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb +); ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope +); ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) > eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope +); ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b public.eql_v3_date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb +); ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope +); ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_date_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) >= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b public.eql_v3_date_ord_ore +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_functions.sql +--! @brief Functions for public.eql_v3_double. + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b public.eql_v3_double --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_double. --! @param a jsonb ---! @param b public.eql_v3_date_ord_ore +--! @param b public.eql_v3_double --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ore) +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b public.eql_v3_double --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_double. --! @param a jsonb ---! @param b public.eql_v3_date_ord_ore +--! @param b public.eql_v3_double --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ore) +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param selector text ---! @return public.eql_v3_date_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ore, selector text) -RETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$ +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a jsonb +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a jsonb +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a jsonb +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a jsonb +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a jsonb +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a jsonb +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param selector text +--! @return public.eql_v3_double +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double, selector text) +RETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double --! @param selector integer ---! @return public.eql_v3_date_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ore, selector integer) -RETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$ +--! @return public.eql_v3_double +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double, selector integer) +RETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_double. --! @param a jsonb ---! @param selector public.eql_v3_date_ord_ore ---! @return public.eql_v3_date_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_ord_ore) -RETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$ +--! @param selector public.eql_v3_double +--! @return public.eql_v3_double +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double) +RETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ore, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ore, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_double. --! @param a jsonb ---! @param selector public.eql_v3_date_ord_ore +--! @param selector public.eql_v3_double --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_ord_ore) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a jsonb +--! @param b public.eql_v3_double +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ore, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double +--! @param b public.eql_v3_double --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double, b public.eql_v3_double) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! @param a public.eql_v3_double --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_double. --! @param a jsonb ---! @param b public.eql_v3_date_ord_ore +--! @param b public.eql_v3_double --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/date_ord_functions.sql ---! @brief Functions for public.eql_v3_date_ord. +--! @file encrypted_domain/double/query_double_eq_functions.sql +--! @brief Functions for eql_v3.query_double_eq. ---! @brief Index extractor for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_date_ord) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for eql_v3.query_double_eq. +--! @param a eql_v3.query_double_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_double_eq) +RETURNS eql_v3_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b public.eql_v3_date_ord +--! @brief Operator wrapper for eql_v3.query_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b eql_v3.query_double_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b public.eql_v3_date_ord) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b eql_v3.query_double_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_double_eq. +--! @param a eql_v3.query_double_eq +--! @param b public.eql_v3_double_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b jsonb) +CREATE FUNCTION eql_v3.eq(a eql_v3.query_double_eq, b public.eql_v3_double_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_date_ord) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a jsonb ---! @param b public.eql_v3_date_ord +--! @brief Operator wrapper for eql_v3.query_double_eq. +--! @param a public.eql_v3_double_eq +--! @param b eql_v3.query_double_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b eql_v3.query_double_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b public.eql_v3_date_ord +--! @brief Operator wrapper for eql_v3.query_double_eq. +--! @param a eql_v3.query_double_eq +--! @param b public.eql_v3_double_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b public.eql_v3_date_ord) +CREATE FUNCTION eql_v3.neq(a eql_v3.query_double_eq, b public.eql_v3_double_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_date_ord) $$; +--! @file encrypted_domain/double/double_ord_ore_operators.sql +--! @brief Operators for public.eql_v3_double_ord_ore. ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a jsonb ---! @param b public.eql_v3_date_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) <> eql_v3.ord_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b public.eql_v3_date_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b public.eql_v3_date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_date_ord) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a jsonb ---! @param b public.eql_v3_date_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) < eql_v3.ord_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b public.eql_v3_date_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b public.eql_v3_date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_date_ord) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a jsonb ---! @param b public.eql_v3_date_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b public.eql_v3_date_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b public.eql_v3_date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_eq_functions.sql +--! @brief Functions for public.eql_v3_integer_eq. + +--! @brief Index extractor for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_integer_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b public.eql_v3_integer_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_date_ord) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_integer_eq) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord. +--! @brief Operator wrapper for public.eql_v3_integer_eq. --! @param a jsonb ---! @param b public.eql_v3_date_ord +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b public.eql_v3_date_ord +--! @brief Operator wrapper for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b public.eql_v3_date_ord) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord +--! @brief Operator wrapper for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_date_ord) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_integer_eq) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord. +--! @brief Operator wrapper for public.eql_v3_integer_eq. --! @param a jsonb ---! @param b public.eql_v3_date_ord +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) <> eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b public.eql_v3_date_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b public.eql_v3_date_ord) +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. --! @param a jsonb ---! @param b public.eql_v3_date_ord +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord) +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b public.eql_v3_date_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b public.eql_v3_date_ord) +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. --! @param a jsonb ---! @param b public.eql_v3_date_ord +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord) +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param selector text ---! @return public.eql_v3_date_ord -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord, selector text) -RETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$ +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b public.eql_v3_integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param selector integer ---! @return public.eql_v3_date_ord -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord, selector integer) -RETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$ +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. --! @param a jsonb ---! @param selector public.eql_v3_date_ord ---! @return public.eql_v3_date_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_ord) -RETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$ +--! @param b public.eql_v3_integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$ +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b public.eql_v3_integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$ +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. --! @param a jsonb ---! @param selector public.eql_v3_date_ord ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_ord) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$ +--! @param b public.eql_v3_integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b text +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_ord, b text) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b text[] +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_ord, b text[]) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b text[] +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a jsonb +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_ord, b text[]) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b jsonpath +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b jsonpath +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_ord, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord'; END; $$ +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a jsonb +--! @param b public.eql_v3_integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_ord, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord'; END; $$ +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param selector text +--! @return public.eql_v3_integer_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_eq, selector text) +RETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$ +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param selector integer +--! @return public.eql_v3_integer_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_eq, selector integer) +RETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$ +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a jsonb +--! @param selector public.eql_v3_integer_eq +--! @return public.eql_v3_integer_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_eq) +RETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a jsonb +--! @param selector public.eql_v3_integer_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b public.eql_v3_integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a jsonb +--! @param b public.eql_v3_integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_ord, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b public.eql_v3_date_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord, b public.eql_v3_date_ord) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b public.eql_v3_integer_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @param a public.eql_v3_integer_eq --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. --! @param a jsonb ---! @param b public.eql_v3_date_ord +--! @param b public.eql_v3_integer_eq --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_ord) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/date_ord_ope_functions.sql ---! @brief Functions for public.eql_v3_date_ord_ope. +--! @file encrypted_domain/integer/integer_ord_functions.sql +--! @brief Functions for public.eql_v3_integer_ord. ---! @brief Index extractor for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Index extractor for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_integer_ord) RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b public.eql_v3_date_ord_ope +--! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_integer_ord) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @brief Operator wrapper for public.eql_v3_integer_ord. --! @param a jsonb ---! @param b public.eql_v3_date_ord_ope +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b public.eql_v3_date_ord_ope +--! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_integer_ord) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @brief Operator wrapper for public.eql_v3_integer_ord. --! @param a jsonb ---! @param b public.eql_v3_date_ord_ope +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b public.eql_v3_date_ord_ope +--! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_integer_ord) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @brief Operator wrapper for public.eql_v3_integer_ord. --! @param a jsonb ---! @param b public.eql_v3_date_ord_ope +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b public.eql_v3_date_ord_ope +--! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_integer_ord) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @brief Operator wrapper for public.eql_v3_integer_ord. --! @param a jsonb ---! @param b public.eql_v3_date_ord_ope +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b public.eql_v3_date_ord_ope +--! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_integer_ord) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @brief Operator wrapper for public.eql_v3_integer_ord. --! @param a jsonb ---! @param b public.eql_v3_date_ord_ope +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b public.eql_v3_date_ord_ope +--! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_integer_ord) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @brief Operator wrapper for public.eql_v3_integer_ord. --! @param a jsonb ---! @param b public.eql_v3_date_ord_ope +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. --! @param a jsonb ---! @param b public.eql_v3_date_ord_ope +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. --! @param a jsonb ---! @param b public.eql_v3_date_ord_ope +--! @param b public.eql_v3_integer_ord --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param selector text ---! @return public.eql_v3_date_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ope, selector text) -RETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$ +--! @return public.eql_v3_integer_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord, selector text) +RETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param selector integer ---! @return public.eql_v3_date_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ope, selector integer) -RETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$ +--! @return public.eql_v3_integer_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord, selector integer) +RETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. --! @param a jsonb ---! @param selector public.eql_v3_date_ord_ope ---! @return public.eql_v3_date_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_ord_ope) -RETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$ +--! @param selector public.eql_v3_integer_ord +--! @return public.eql_v3_integer_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_ord) +RETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ope, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ope, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. --! @param a jsonb ---! @param selector public.eql_v3_date_ord_ope +--! @param selector public.eql_v3_integer_ord --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_ord) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_ord_ope, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b public.eql_v3_integer_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a jsonb +--! @param b public.eql_v3_integer_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_integer_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ope, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ope, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b public.eql_v3_integer_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @param a public.eql_v3_integer_ord --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ope, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. --! @param a jsonb ---! @param b public.eql_v3_date_ord_ope +--! @param b public.eql_v3_integer_ord --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_ord_ope) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/date_eq_functions.sql ---! @brief Functions for public.eql_v3_date_eq. +--! @file encrypted_domain/integer/integer_ord_operators.sql +--! @brief Operators for public.eql_v3_integer_ord. ---! @brief Index extractor for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_date_eq) -RETURNS eql_v3_internal.hmac_256 +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ore_functions.sql +--! @brief Functions for public.eql_v3_integer_ord_ore. + +--! @brief Index extractor for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_integer_ord_ore) +RETURNS eql_v3_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b public.eql_v3_date_eq) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b jsonb) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_date_eq) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_date_eq. +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_date_eq +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_eq) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b public.eql_v3_date_eq) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_date_eq) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_date_eq. +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_date_eq +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_eq) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) <> eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b public.eql_v3_date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_date_eq +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) < eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b public.eql_v3_date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_date_eq +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) <= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b public.eql_v3_date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_date_eq +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) > eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b public.eql_v3_date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Operator wrapper for public.eql_v3_integer_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_date_eq +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date_eq) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) >= eql_v3.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b public.eql_v3_date_eq) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_date_eq +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_eq) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b public.eql_v3_date_eq) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_date_eq +--! @param b public.eql_v3_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_eq) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param selector text ---! @return public.eql_v3_date_eq -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_eq, selector text) -RETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$ +--! @return public.eql_v3_integer_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ore, selector text) +RETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param selector integer ---! @return public.eql_v3_date_eq -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_eq, selector integer) -RETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$ +--! @return public.eql_v3_integer_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ore, selector integer) +RETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. --! @param a jsonb ---! @param selector public.eql_v3_date_eq ---! @return public.eql_v3_date_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_eq) -RETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$ +--! @param selector public.eql_v3_integer_ord_ore +--! @return public.eql_v3_integer_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_ord_ore) +RETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_eq, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_eq, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. --! @param a jsonb ---! @param selector public.eql_v3_date_eq +--! @param selector public.eql_v3_integer_ord_ore --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_eq) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_eq, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_integer_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_eq, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_eq, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_eq, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_eq, b public.eql_v3_date_eq) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_eq, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_date_eq +--! @param b public.eql_v3_integer_ord_ore --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_eq) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file v3/scalars/boolean/boolean_types.sql ---! @brief Encrypted-domain types for boolean. +--! @file encrypted_domain/integer/integer_ord_ore_operators.sql +--! @brief Operators for public.eql_v3_integer_ord_ore. -DO $$ -BEGIN - --! @brief Encrypted domain public.eql_v3_boolean. - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_boolean' AND typnamespace = 'public'::regnamespace - ) THEN - CREATE DOMAIN public.eql_v3_boolean AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'c' - AND VALUE->>'v' = '3' - ); - END IF; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - COMMENT ON DOMAIN public.eql_v3_boolean IS 'EQL encrypted boolean (storage only)'; -END -$$; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @file v3/scalars/bigint/query_bigint_types.sql ---! @brief Query-operand domains for bigint (index-terms-only, no ciphertext). ---! @note Query-operand domains live in `eql_v3` (not `public`): they are ---! never valid column types, so they don't belong in the column-type ---! namespace, and dropping the EQL-owned schema can never drop an ---! application column. ---! @note Cast a query operand explicitly to its `query_` domain in a predicate ---! (e.g. `WHERE col = $1::eql_v3.query_bigint_eq`). A bare, ---! uncast literal RHS is ambiguous between the `query_` and `jsonb` ---! operator overloads and will not resolve. +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); -DO $$ -BEGIN - --! @brief Query-operand domain eql_v3.query_bigint_eq (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_bigint_eq' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_bigint_eq AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'hm' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); - COMMENT ON DOMAIN eql_v3.query_bigint_eq IS 'EQL bigint query operand (equality)'; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); - --! @brief Query-operand domain eql_v3.query_bigint_ord_ore (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_bigint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_bigint_ord_ore AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'ob' - AND NOT (VALUE ? 'c') - AND jsonb_typeof(VALUE -> 'ob') = 'array' - AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' - ); - END IF; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); - COMMENT ON DOMAIN eql_v3.query_bigint_ord_ore IS 'EQL bigint query operand (equality, ordering)'; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); - --! @brief Query-operand domain eql_v3.query_bigint_ord (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_bigint_ord' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_bigint_ord AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'op' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); - COMMENT ON DOMAIN eql_v3.query_bigint_ord IS 'EQL bigint query operand (equality, ordering)'; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); - --! @brief Query-operand domain eql_v3.query_bigint_ord_ope (term-only; no `c`). - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_bigint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_bigint_ord_ope AS jsonb - CHECK ( - jsonb_typeof(VALUE) = 'object' - AND VALUE ? 'v' - AND VALUE ? 'i' - AND VALUE ? 'op' - AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' - ); - END IF; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); - COMMENT ON DOMAIN eql_v3.query_bigint_ord_ope IS 'EQL bigint query operand (equality, ordering)'; -END -$$; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @file encrypted_domain/bigint/bigint_ord_ore_functions.sql ---! @brief Functions for public.eql_v3_bigint_ord_ore. +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Index extractor for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_bigint_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) = eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord_ore) +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/integer/query_integer_types.sql +--! @brief Query-operand domains for integer (index-terms-only, no ciphertext). +--! @note Query-operand domains live in `eql_v3` (not `public`): they are +--! never valid column types, so they don't belong in the column-type +--! namespace, and dropping the EQL-owned schema can never drop an +--! application column. +--! @note Cast a query operand explicitly to its `query_` domain in a predicate +--! (e.g. `WHERE col = $1::eql_v3.query_integer_eq`). A bare, +--! uncast literal RHS is ambiguous between the `query_` and `jsonb` +--! operator overloads and will not resolve. + +DO $$ +BEGIN + --! @brief Query-operand domain eql_v3.query_integer_eq (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_integer_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_integer_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_integer_eq IS 'EQL integer query operand (equality)'; + + --! @brief Query-operand domain eql_v3.query_integer_ord_ore (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_integer_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_integer_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_integer_ord_ore IS 'EQL integer query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_integer_ord (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_integer_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_integer_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_integer_ord IS 'EQL integer query operand (equality, ordering)'; + + --! @brief Query-operand domain eql_v3.query_integer_ord_ope (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_integer_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_integer_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN eql_v3.query_integer_ord_ope IS 'EQL integer query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ope_functions.sql +--! @brief Functions for public.eql_v3_integer_ord_ope. + +--! @brief Index extractor for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_integer_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b jsonb) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$; + +--! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param selector text ---! @return public.eql_v3_bigint_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ore, selector text) -RETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$ +--! @return public.eql_v3_integer_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ope, selector text) +RETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param selector integer ---! @return public.eql_v3_bigint_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ore, selector integer) -RETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$ +--! @return public.eql_v3_integer_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ope, selector integer) +RETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. --! @param a jsonb ---! @param selector public.eql_v3_bigint_ord_ore ---! @return public.eql_v3_bigint_ord_ore -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_ord_ore) -RETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$ +--! @param selector public.eql_v3_integer_ord_ope +--! @return public.eql_v3_integer_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_ord_ope) +RETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ore, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ore, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. --! @param a jsonb ---! @param selector public.eql_v3_bigint_ord_ore +--! @param selector public.eql_v3_integer_ord_ope --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_ord_ore) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_integer_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ore, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ore, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ore, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_ord_ore, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ore, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ore +--! @param b public.eql_v3_integer_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/bigint/bigint_ord_functions.sql ---! @brief Functions for public.eql_v3_bigint_ord. - ---! @brief Index extractor for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_bigint_ord) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +--! @file encrypted_domain/integer/integer_functions.sql +--! @brief Functions for public.eql_v3_integer. ---! @brief Operator wrapper for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b public.eql_v3_integer --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$; +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord +--! @param b public.eql_v3_integer --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) = eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b public.eql_v3_integer --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$; +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord +--! @param b public.eql_v3_integer --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) <> eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b public.eql_v3_integer --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$; +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord +--! @param b public.eql_v3_integer --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) < eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b public.eql_v3_integer --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$; +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord +--! @param b public.eql_v3_integer --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) <= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b public.eql_v3_integer --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$; +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord +--! @param b public.eql_v3_integer --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) > eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b public.eql_v3_integer --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$; +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord +--! @param b public.eql_v3_integer --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) >= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b public.eql_v3_integer --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord +--! @param b public.eql_v3_integer --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b public.eql_v3_integer --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord +--! @param b public.eql_v3_integer --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param selector text ---! @return public.eql_v3_bigint_ord -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord, selector text) -RETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$ +--! @return public.eql_v3_integer +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer, selector text) +RETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param selector integer ---! @return public.eql_v3_bigint_ord -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord, selector integer) -RETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$ +--! @return public.eql_v3_integer +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer, selector integer) +RETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer. --! @param a jsonb ---! @param selector public.eql_v3_bigint_ord ---! @return public.eql_v3_bigint_ord -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_ord) -RETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$ +--! @param selector public.eql_v3_integer +--! @return public.eql_v3_integer +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer) +RETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer. --! @param a jsonb ---! @param selector public.eql_v3_bigint_ord +--! @param selector public.eql_v3_integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_ord) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_ord, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_ord, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b jsonpath +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b public.eql_v3_integer --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a jsonb +--! @param b public.eql_v3_integer +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_ord, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer +--! @param b public.eql_v3_integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @param a public.eql_v3_integer --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.eql_v3_integer. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord +--! @param b public.eql_v3_integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_ord) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/bigint/bigint_ord_ope_functions.sql ---! @brief Functions for public.eql_v3_bigint_ord_ope. +--! @file encrypted_domain/integer/query_integer_eq_functions.sql +--! @brief Functions for eql_v3.query_integer_eq. ---! @brief Index extractor for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_bigint_ord_ope) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for eql_v3.query_integer_eq. +--! @param a eql_v3.query_integer_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_integer_eq) +RETURNS eql_v3_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope +--! @brief Operator wrapper for eql_v3.query_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b eql_v3.query_integer_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b eql_v3.query_integer_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonb +--! @brief Operator wrapper for eql_v3.query_integer_eq. +--! @param a eql_v3.query_integer_eq +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b jsonb) +CREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ope +--! @brief Operator wrapper for eql_v3.query_integer_eq. +--! @param a public.eql_v3_integer_eq +--! @param b eql_v3.query_integer_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord_ope) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b eql_v3.query_integer_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope +--! @brief Operator wrapper for eql_v3.query_integer_eq. +--! @param a eql_v3.query_integer_eq +--! @param b public.eql_v3_integer_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +CREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$; +--! @file v3/sem/ore_block_256/operator_class.sql +--! @brief B-tree operator family + default class on eql_v3_internal.ore_block_256. +--! +--! Gives the composite type its DEFAULT btree opclass so the recommended +--! functional index `CREATE INDEX ON t (eql_v3.ord_term_ore(col))` engages without +--! an explicit opclass annotation (design D4). +--! +--! @note Creating an operator family/class requires superuser: Postgres forbids +--! CREATE OPERATOR FAMILY / CLASS to non-superusers to protect index +--! integrity. Managed platforms (Supabase, and most hosted Postgres) run +--! the installer as a non-superuser role, so the DO block below ATTEMPTS +--! the creation and skips it on insufficient_privilege (SQLSTATE 42501), +--! letting the single installer run everywhere. When the class is absent, +--! ORE ordered scans over eql_v3_internal.ore_block_256 are unavailable, +--! but the order-preserving (OPE) ordering domains — whose extractor +--! return types carry a native btree opclass — still index without it. On +--! superuser installs (self-managed Postgres, the SQLx test matrix) the +--! class is created normally. Any non-privilege error still propagates. +--! @see eql_v3_internal.compare_ore_block_256_terms ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) <> eql_v3.ord_term(b) $$; +DO $do$ +BEGIN + EXECUTE 'CREATE OPERATOR FAMILY eql_v3_internal.ore_block_256_operator_family USING btree'; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + EXECUTE $ddl$ + CREATE OPERATOR CLASS eql_v3_internal.ore_block_256_operator_class + DEFAULT FOR TYPE eql_v3_internal.ore_block_256 + USING btree FAMILY eql_v3_internal.ore_block_256_operator_family AS + OPERATOR 1 public.<, + OPERATOR 2 public.<=, + OPERATOR 3 public.=, + OPERATOR 4 public.>=, + OPERATOR 5 public.>, + FUNCTION 1 eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) + $ddl$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$; + RAISE NOTICE 'EQL: created btree operator class eql_v3_internal.ore_block_256_operator_class'; +EXCEPTION + WHEN insufficient_privilege THEN + 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'; +END; +$do$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) < eql_v3.ord_term(b) $$; +--! @file v3/scalars/timestamp/query_timestamp_types.sql +--! @brief Query-operand domains for timestamp (index-terms-only, no ciphertext). +--! @note Query-operand domains live in `eql_v3` (not `public`): they are +--! never valid column types, so they don't belong in the column-type +--! namespace, and dropping the EQL-owned schema can never drop an +--! application column. +--! @note Cast a query operand explicitly to its `query_` domain in a predicate +--! (e.g. `WHERE col = $1::eql_v3.query_timestamp_eq`). A bare, +--! uncast literal RHS is ambiguous between the `query_` and `jsonb` +--! operator overloads and will not resolve. ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +DO $$ +BEGIN + --! @brief Query-operand domain eql_v3.query_timestamp_eq (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_timestamp_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_timestamp_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$; + COMMENT ON DOMAIN eql_v3.query_timestamp_eq IS 'EQL timestamp query operand (equality)'; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) <= eql_v3.ord_term(b) $$; + --! @brief Query-operand domain eql_v3.query_timestamp_ord_ore (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_timestamp_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_timestamp_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + COMMENT ON DOMAIN eql_v3.query_timestamp_ord_ore IS 'EQL timestamp query operand (equality, ordering)'; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$; + --! @brief Query-operand domain eql_v3.query_timestamp_ord (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_timestamp_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_timestamp_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) > eql_v3.ord_term(b) $$; + COMMENT ON DOMAIN eql_v3.query_timestamp_ord IS 'EQL timestamp query operand (equality, ordering)'; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + --! @brief Query-operand domain eql_v3.query_timestamp_ord_ope (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_timestamp_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_timestamp_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$; + COMMENT ON DOMAIN eql_v3.query_timestamp_ord_ope IS 'EQL timestamp query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) >= eql_v3.ord_term(b) $$; +--! @file v3/scalars/text/query_text_types.sql +--! @brief Query-operand domains for text (index-terms-only, no ciphertext). +--! @note Query-operand domains live in `eql_v3` (not `public`): they are +--! never valid column types, so they don't belong in the column-type +--! namespace, and dropping the EQL-owned schema can never drop an +--! application column. +--! @note Cast a query operand explicitly to its `query_` domain in a predicate +--! (e.g. `WHERE col = $1::eql_v3.query_text_eq`). A bare, +--! uncast literal RHS is ambiguous between the `query_` and `jsonb` +--! operator overloads and will not resolve. ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; +DO $$ +BEGIN + --! @brief Query-operand domain eql_v3.query_text_eq (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_text_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_text_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; + COMMENT ON DOMAIN eql_v3.query_text_eq IS 'EQL text query operand (equality)'; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; + --! @brief Query-operand domain eql_v3.query_text_match (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_text_match' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_text_match AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'bf' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; + COMMENT ON DOMAIN eql_v3.query_text_match IS 'EQL text query operand (matching)'; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; + --! @brief Query-operand domain eql_v3.query_text_ord_ore (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_text_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_text_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ope) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; + COMMENT ON DOMAIN eql_v3.query_text_ord_ore IS 'EQL text query operand (equality, ordering)'; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param selector text ---! @return public.eql_v3_bigint_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ope, selector text) -RETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; + --! @brief Query-operand domain eql_v3.query_text_ord (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_text_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_text_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param selector integer ---! @return public.eql_v3_bigint_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ope, selector integer) -RETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; + COMMENT ON DOMAIN eql_v3.query_text_ord IS 'EQL text query operand (equality, ordering)'; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_bigint_ord_ope ---! @return public.eql_v3_bigint_ord_ope -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_ord_ope) -RETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; + --! @brief Query-operand domain eql_v3.query_text_ord_ope (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_text_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_text_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ope, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; + COMMENT ON DOMAIN eql_v3.query_text_ord_ope IS 'EQL text query operand (equality, ordering)'; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ope, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; + --! @brief Query-operand domain eql_v3.query_text_search_ore (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_text_search_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_text_search_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND VALUE ? 'ob' + AND VALUE ? 'bf' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_bigint_ord_ope ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_ord_ope) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; + COMMENT ON DOMAIN eql_v3.query_text_search_ore IS 'EQL text query operand (equality, ordering, matching)'; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_ord_ope, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; + --! @brief Query-operand domain eql_v3.query_text_search (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_text_search' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_text_search AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND VALUE ? 'op' + AND VALUE ? 'bf' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text[] + COMMENT ON DOMAIN eql_v3.query_text_search IS 'EQL text query operand (equality, ordering, matching)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_match_functions.sql +--! @brief Functions for public.eql_v3_text_match. + +--! @brief Index extractor for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @return eql_v3_internal.bloom_filter +CREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_match) +RETURNS eql_v3_internal.bloom_filter +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; + +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text[] +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_ord_ope, b text[]) +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonpath +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a jsonb +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonpath +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ope, b jsonpath) +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_ord_ope, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ope, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ope, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_ord_ope, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ope, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ope ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_ord_ope) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_eq_functions.sql ---! @brief Functions for public.eql_v3_bigint_eq. - ---! @brief Index extractor for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_bigint_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Operator wrapper for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_bigint_eq) $$; - ---! @brief Operator wrapper for public.eql_v3_bigint_eq. ---! @param a jsonb ---! @param b public.eql_v3_bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_bigint_eq) $$; +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_text_match. --! @param a jsonb ---! @param b public.eql_v3_bigint_eq +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) <> eql_v3.eq_term(b) $$; +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$ +LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_text_match. --! @param a jsonb ---! @param b public.eql_v3_bigint_eq +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint_eq) +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_text_match. --! @param a jsonb ---! @param b public.eql_v3_bigint_eq +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint_eq) +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_text_match. --! @param a jsonb ---! @param b public.eql_v3_bigint_eq +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint_eq) +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_text_match. --! @param a jsonb ---! @param b public.eql_v3_bigint_eq +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint_eq) +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_text_match. --! @param a jsonb ---! @param b public.eql_v3_bigint_eq +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_eq) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_text_match. --! @param a jsonb ---! @param b public.eql_v3_bigint_eq +--! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_eq) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param selector text ---! @return public.eql_v3_bigint_eq -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_eq, selector text) -RETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$ +--! @return public.eql_v3_text_match +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_match, selector text) +RETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param selector integer ---! @return public.eql_v3_bigint_eq -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_eq, selector integer) -RETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$ +--! @return public.eql_v3_text_match +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_match, selector integer) +RETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_text_match. --! @param a jsonb ---! @param selector public.eql_v3_bigint_eq ---! @return public.eql_v3_bigint_eq -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_eq) -RETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$ +--! @param selector public.eql_v3_text_match +--! @return public.eql_v3_text_match +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_match) +RETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_eq, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_match, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_eq, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_match, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_text_match. --! @param a jsonb ---! @param selector public.eql_v3_bigint_eq +--! @param selector public.eql_v3_text_match --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_eq) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_match) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_eq, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_match, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_match, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_eq, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_match, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_match, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Operator wrapper for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @param b public.eql_v3_text_match +--! @return boolean +CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b public.eql_v3_text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_match) $$; + +--! @brief Operator wrapper for public.eql_v3_text_match. +--! @param a jsonb +--! @param b public.eql_v3_text_match +--! @return boolean +CREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_match) @> eql_v3.match_term(b) $$; + +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_eq, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_match, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_match, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_match, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_eq, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_match, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_eq, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_match, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_eq, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_match, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_eq, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_match, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @param b public.eql_v3_text_match --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_eq, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_match, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.eql_v3_text_match. --! @param a jsonb ---! @param b public.eql_v3_bigint_eq +--! @param b public.eql_v3_text_match --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_eq) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_match) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. ---! @file v3/jsonb/types.sql ---! @brief Domain types for the eql_v3 encrypted-JSONB (SteVec) surface. ---! ---! Three jsonb-backed domains (none over another domain — operators resolve ---! against the ultimate base type jsonb, so the native-jsonb firewall in ---! blockers.sql can attach): ---! - public.eql_v3_json — storage/root: an EQL envelope object ({i, v, ...}). ---! - public.eql_v3_jsonb_entry — a single sv element (returned by `->`). ---! - eql_v3.query_jsonb — a containment needle (sv elements, no ciphertext). - ---! @brief Validate a single SteVec entry payload. ---! @internal ---! @param val jsonb Candidate entry payload. ---! @return boolean True when `val` is an sv entry with string `s`, string `c`, ---! and exactly one string deterministic term (`hm` XOR `op`). -CREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_entry_payload(val jsonb) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT COALESCE( - jsonb_typeof(val) = 'object' - AND jsonb_typeof(val -> 's') = 'string' - AND jsonb_typeof(val -> 'c') = 'string' - AND ( - (jsonb_typeof(val -> 'hm') = 'string' AND NOT (val ? 'op')) - OR - (jsonb_typeof(val -> 'op') = 'string' AND NOT (val ? 'hm')) - ), - false - ) -$$; +--! @file encrypted_domain/text/text_ord_ope_functions.sql +--! @brief Functions for public.eql_v3_text_ord_ope. ---! @brief Validate a SteVec containment query payload. ---! @internal ---! @param val jsonb Candidate query payload. ---! @return boolean True when `val` is `{"sv":[...]}` and every element carries ---! string `s`, no ciphertext, and exactly one string term (`hm` XOR ---! `op`). ---! @note plpgsql, not LANGUAGE sql (issues #353/#354): the only caller is the ---! eql_v3.query_jsonb domain CHECK, where a SQL function can never be ---! inlined (and the CHECK itself cannot absorb this body — it needs a ---! subquery over the sv elements, which CHECK constraints forbid). plpgsql ---! caches its plan across calls instead of paying the per-call SQL-function ---! executor on every needle cast. -CREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_query_payload(val jsonb) - RETURNS boolean - LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -AS $$ -BEGIN - RETURN COALESCE( - jsonb_typeof(val) = 'object' - AND jsonb_typeof(val -> 'sv') = 'array' - AND NOT EXISTS ( - SELECT 1 - FROM jsonb_array_elements( - CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END - ) AS elem - WHERE NOT COALESCE(( - jsonb_typeof(elem) = 'object' - AND jsonb_typeof(elem -> 's') = 'string' - AND NOT (elem ? 'c') - AND ( - (jsonb_typeof(elem -> 'hm') = 'string' AND NOT (elem ? 'op')) - OR - (jsonb_typeof(elem -> 'op') = 'string' AND NOT (elem ? 'hm')) - ) - ), false) - ), - false - ); -END; -$$; +--! @brief Index extractor for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord_ope) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Validate a root SteVec document payload. ---! @internal ---! @param val jsonb Candidate document payload. ---! @return boolean True when `val` is an encrypted document envelope with ---! `v = 3`, `i`, an `sv` array, and valid sv entry elements. -CREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_document_payload(val jsonb) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT COALESCE( - jsonb_typeof(val) = 'object' - AND val ? 'v' - AND val ->> 'v' = '3' - AND val ? 'i' - AND jsonb_typeof(val -> 'sv') = 'array' - AND NOT EXISTS ( - SELECT 1 - FROM jsonb_array_elements( - CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END - ) AS elem - WHERE NOT public.eql_v3_is_valid_ste_vec_entry_payload(elem) - ), - false - ) -$$; +--! @brief Index extractor for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Storage/root domain for an encrypted JSONB column. ---! ---! CHECK: a JSON object carrying the EQL envelope (`v = 3` version and `i` index ---! metadata). Root `c` is intentionally NOT required — an sv-array root payload ---! is `{i, v, sv}` with no root ciphertext. The CHECK now also requires an `sv` ---! array, so the domain accepts only SteVec **document** payloads and rejects ---! encrypted *scalar* payloads (which carry `c`/`hm`/`ob` but no `sv`) — this is ---! what keeps `public.eql_v3_json` a typed document domain rather than a generic ---! encrypted envelope. The firewall in blockers.sql attaches to this domain to ---! stop native jsonb operators from reaching a column value. ---! ---! @note Constructing from inline JSON uses the standard DOMAIN cast: ---! `'{"i":{},"v":3,"sv":[...]}'::public.eql_v3_json`. -DO $$ -BEGIN - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_json' AND typnamespace = 'public'::regnamespace - ) THEN - CREATE DOMAIN public.eql_v3_json AS jsonb - CHECK ( - public.eql_v3_is_valid_ste_vec_document_payload(VALUE) - ); - END IF; +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - COMMENT ON DOMAIN public.eql_v3_json IS 'EQL encrypted JSONB document (containment, equality, ordering)'; -END -$$; +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord_ope) $$; ---! @brief Domain type for an individual sv element. ---! ---! A single element inside an `sv` array: a JSON object that carries a selector ---! (`s`), a ciphertext (`c`), and **exactly one** of `hm` (HMAC-256, for ---! hash-equality) or `op` (CLLW OPE, for ordered queries) — they are mutually ---! exclusive. This is the type returned by `->` and accepted by the per-entry ---! extractors `eql_v3.eq_term` / `eql_v3.ord_term`. Extra fields (`a`, root ---! `i`/`v` merged in by `->`) are allowed. ---! ---! @see src/v3/jsonb/operators.sql ---! ---! @internal ---! Implementation note (issue #354): the CHECK is an INLINE expression, not a ---! call to `public.eql_v3_is_valid_ste_vec_entry_payload` — domain ---! constraints cannot inline SQL functions, so the function-call form paid ---! the per-call SQL-function executor (~18 µs) on EVERY cast: the needle ---! cast in every field_eq query (+19% end-to-end vs v2, the entire measured ---! regression on that scenario; see cipherstash/benches#23). The expression ---! mirrors the validator body; the leading `VALUE IS NULL OR` preserves the ---! validator's STRICT NULL-passes semantics (a bare COALESCE(..., false) ---! would reject NULL, which `->` returns for a missing selector). Keep the ---! two in sync — `jsonb_entry_check_matches_validator` in tests/sqlx pins ---! the equivalence. ---! @endinternal -DO $$ -BEGIN - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_jsonb_entry' AND typnamespace = 'public'::regnamespace - ) THEN - CREATE DOMAIN public.eql_v3_jsonb_entry AS jsonb - CHECK ( - VALUE IS NULL - OR COALESCE( - jsonb_typeof(VALUE) = 'object' - AND jsonb_typeof(VALUE -> 's') = 'string' - AND jsonb_typeof(VALUE -> 'c') = 'string' - AND ( - (jsonb_typeof(VALUE -> 'hm') = 'string' AND NOT (VALUE ? 'op')) - OR - (jsonb_typeof(VALUE -> 'op') = 'string' AND NOT (VALUE ? 'hm')) - ), - false - ) - ); - END IF; +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ope) = eql_v3.eq_term(b) $$; - COMMENT ON DOMAIN public.eql_v3_jsonb_entry IS 'EQL encrypted JSONB leaf entry (equality, ordering)'; -END -$$; +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Domain type for an STE-vec containment needle. ---! ---! A query-shaped payload `{"sv":[...]}` whose elements carry selector + index ---! term but **never** a ciphertext (`c`). Each element must carry `s` and ---! exactly one deterministic term (`hm` XOR `op`). Typing the needle this way ---! stops selector-only needles from casting and matching every row via bare ---! `jsonb @>`. ---! ---! @note Construct from inline JSON via the DOMAIN cast: ---! `'{"sv":[{"s":"","hm":""}]}'::eql_v3.query_jsonb`. ---! @see eql_v3.to_ste_vec_query ---! ---! @internal ---! Implementation note (issue #354): this CHECK CANNOT be inlined like ---! public.eql_v3_jsonb_entry's — validating the sv elements requires a subquery ---! (`NOT EXISTS (SELECT ... FROM jsonb_array_elements(...))`), and CHECK ---! constraints forbid subqueries. The validator is plpgsql instead (cached ---! plan; substantially cheaper per call than a non-inlined LANGUAGE sql ---! function — the same finding as issue #353), since this cast sits on the ---! per-query hot path of every containment scenario ---! (`$1::jsonb::eql_v3.query_jsonb`). ---! @endinternal -DO $$ -BEGIN - IF NOT EXISTS ( - SELECT 1 FROM pg_type - WHERE typname = 'query_jsonb' AND typnamespace = 'eql_v3'::regnamespace - ) THEN - CREATE DOMAIN eql_v3.query_jsonb AS jsonb - CHECK ( - public.eql_v3_is_valid_ste_vec_query_payload(VALUE) - ); - END IF; +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord_ope) $$; - COMMENT ON DOMAIN eql_v3.query_jsonb IS 'EQL JSONB query operand (containment)'; -END -$$; +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ope) <> eql_v3.eq_term(b) $$; ---! @brief Convert a public.eql_v3_json to a query_jsonb needle. ---! ---! Normalises each sv element down to the matching-relevant fields: `s` plus ---! exactly one of `hm` / `op`. Other fields (`c`, `a`, `i`/`v`, anything else) ---! are stripped. This is the canonical needle shape for `@>` containment. ---! Designed for use as a functional GIN index expression: ---! `GIN (eql_v3.to_ste_vec_query(col)::jsonb jsonb_path_ops)`. ---! ---! @param e public.eql_v3_json Source encrypted payload ---! @return eql_v3.query_jsonb Query-shaped needle, sv elements normalised. ---! @see eql_v3.query_jsonb -CREATE FUNCTION eql_v3.to_ste_vec_query(e public.eql_v3_json) - RETURNS eql_v3.query_jsonb - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT jsonb_build_object( - 'sv', - coalesce( - (SELECT jsonb_agg( - jsonb_strip_nulls( - jsonb_build_object( - 's', elem -> 's', - 'hm', elem -> 'hm', - 'op', elem -> 'op' - ) - ) - ) - FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem), - '[]'::jsonb - ) - )::eql_v3.query_jsonb -$$; +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE CAST (public.eql_v3_json AS eql_v3.query_jsonb) - WITH FUNCTION eql_v3.to_ste_vec_query - AS ASSIGNMENT; --- AUTOMATICALLY GENERATED FILE. +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$; ---! @file encrypted_domain/timestamp/timestamp_ord_ore_operators.sql ---! @brief Operators for public.eql_v3_timestamp_ord_ore. +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) < eql_v3.ord_term(b) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) > eql_v3.ord_term(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) >= eql_v3.ord_term(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param selector text +--! @return public.eql_v3_text_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ope, selector text) +RETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param selector integer +--! @return public.eql_v3_text_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ope, selector integer) +RETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a jsonb +--! @param selector public.eql_v3_text_ord_ope +--! @return public.eql_v3_text_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_ord_ope) +RETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a jsonb +--! @param selector public.eql_v3_text_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_text_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b public.eql_v3_text_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer -); +--! @file encrypted_domain/text/query_text_ord_functions.sql +--! @brief Functions for eql_v3.query_text_ord. -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[] -); +--! @brief Index extractor for eql_v3.query_text_ord. +--! @param a eql_v3.query_text_ord +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[] -); +--! @brief Index extractor for eql_v3.query_text_ord. +--! @param a eql_v3.query_text_ord +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_ord) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore -); +--! @brief Operator wrapper for eql_v3.query_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b eql_v3.query_text_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b eql_v3.query_text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb -); +--! @brief Operator wrapper for eql_v3.query_text_ord. +--! @param a eql_v3.query_text_ord +--! @param b public.eql_v3_text_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord, b public.eql_v3_text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Operator wrapper for eql_v3.query_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b eql_v3.query_text_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b eql_v3.query_text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @file encrypted_domain/timestamp/timestamp_ord_ope_operators.sql ---! @brief Operators for public.eql_v3_timestamp_ord_ope. +--! @brief Operator wrapper for eql_v3.query_text_ord. +--! @param a eql_v3.query_text_ord +--! @param b public.eql_v3_text_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord, b public.eql_v3_text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b eql_v3.query_text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b eql_v3.query_text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord. +--! @param a eql_v3.query_text_ord +--! @param b public.eql_v3_text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord, b public.eql_v3_text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b eql_v3.query_text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b eql_v3.query_text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord. +--! @param a eql_v3.query_text_ord +--! @param b public.eql_v3_text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord, b public.eql_v3_text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b eql_v3.query_text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b eql_v3.query_text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord. +--! @param a eql_v3.query_text_ord +--! @param b public.eql_v3_text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord, b public.eql_v3_text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord. +--! @param a public.eql_v3_text_ord +--! @param b eql_v3.query_text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b eql_v3.query_text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord. +--! @param a eql_v3.query_text_ord +--! @param b public.eql_v3_text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord, b public.eql_v3_text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @file encrypted_domain/text/text_ord_ore_functions.sql +--! @brief Functions for public.eql_v3_text_ord_ore. -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Index extractor for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord_ore) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Index extractor for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_text_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord_ore) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ore) = eql_v3.eq_term(b) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord_ore) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ore) <> eql_v3.eq_term(b) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) < eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) <= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) > eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer -); +--! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) >= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param selector text +--! @return public.eql_v3_text_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ore, selector text) +RETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param selector integer +--! @return public.eql_v3_text_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ore, selector integer) +RETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a jsonb +--! @param selector public.eql_v3_text_ord_ore +--! @return public.eql_v3_text_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_ord_ore) +RETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a jsonb +--! @param selector public.eql_v3_text_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; ---! @file encrypted_domain/timestamp/timestamp_ord_operators.sql ---! @brief Operators for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b public.eql_v3_text_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord -); +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/timestamp/timestamp_functions.sql ---! @brief Functions for public.eql_v3_timestamp. +--! @file encrypted_domain/text/text_eq_functions.sql +--! @brief Functions for public.eql_v3_text_eq. ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp +--! @brief Index extractor for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b public.eql_v3_timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b public.eql_v3_text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Operator wrapper for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_eq) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Operator wrapper for public.eql_v3_text_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) = eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp +--! @brief Operator wrapper for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b public.eql_v3_timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b public.eql_v3_text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Operator wrapper for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_eq) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Operator wrapper for public.eql_v3_text_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_timestamp) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) <> eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b jsonb) +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp) +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b jsonb) +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp) +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b jsonb) +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp) +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b jsonb) +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp) +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp +--! @param b public.eql_v3_text_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param selector text ---! @return public.eql_v3_timestamp -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp, selector text) -RETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$ +--! @return public.eql_v3_text_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_eq, selector text) +RETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param selector integer ---! @return public.eql_v3_timestamp -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp, selector integer) -RETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$ +--! @return public.eql_v3_text_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_eq, selector integer) +RETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. --! @param a jsonb ---! @param selector public.eql_v3_timestamp ---! @return public.eql_v3_timestamp -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp) -RETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$ +--! @param selector public.eql_v3_text_eq +--! @return public.eql_v3_text_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_eq) +RETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. --! @param a jsonb ---! @param selector public.eql_v3_timestamp +--! @param selector public.eql_v3_text_eq --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_eq) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b public.eql_v3_text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_eq, b public.eql_v3_text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a jsonb +--! @param b public.eql_v3_text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b public.eql_v3_text_eq --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @param a public.eql_v3_text_eq --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp +--! @param b public.eql_v3_text_eq --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/timestamp/query_timestamp_ord_ore_functions.sql ---! @brief Functions for eql_v3.query_timestamp_ord_ore. +--! @file encrypted_domain/text/text_search_functions.sql +--! @brief Functions for public.eql_v3_text_search. ---! @brief Index extractor for eql_v3.query_timestamp_ord_ore. ---! @param a eql_v3.query_timestamp_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_timestamp_ord_ore) -RETURNS eql_v3_internal.ore_block_256 +--! @brief Index extractor for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_search) +RETURNS eql_v3_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b eql_v3.query_timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +--! @brief Index extractor for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_search) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. ---! @param a eql_v3.query_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +--! @brief Index extractor for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @return eql_v3_internal.bloom_filter +CREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_search) +RETURNS eql_v3_internal.bloom_filter +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b eql_v3.query_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. ---! @param a eql_v3.query_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_search) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b eql_v3.query_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a jsonb +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. ---! @param a eql_v3.query_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b eql_v3.query_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_search) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. ---! @param a eql_v3.query_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a jsonb +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b eql_v3.query_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. ---! @param a eql_v3.query_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_search) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b eql_v3.query_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a jsonb +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore) +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. ---! @param a eql_v3.query_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/query_timestamp_ord_functions.sql ---! @brief Functions for eql_v3.query_timestamp_ord. - ---! @brief Index extractor for eql_v3.query_timestamp_ord. ---! @param a eql_v3.query_timestamp_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_timestamp_ord) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b eql_v3.query_timestamp_ord +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_search) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord. ---! @param a eql_v3.query_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a jsonb +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord) +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b eql_v3.query_timestamp_ord +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord. ---! @param a eql_v3.query_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_search) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b eql_v3.query_timestamp_ord +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a jsonb +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord) +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord. ---! @param a eql_v3.query_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b eql_v3.query_timestamp_ord +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_search) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord. ---! @param a eql_v3.query_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a jsonb +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord) +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b eql_v3.query_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b public.eql_v3_text_search) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord. ---! @param a eql_v3.query_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b eql_v3.query_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a jsonb +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord. ---! @param a eql_v3.query_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/query_timestamp_ord_ope_functions.sql ---! @brief Functions for eql_v3.query_timestamp_ord_ope. - ---! @brief Index extractor for eql_v3.query_timestamp_ord_ope. ---! @param a eql_v3.query_timestamp_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_timestamp_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b public.eql_v3_text_search) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b eql_v3.query_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. ---! @param a eql_v3.query_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a jsonb +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b eql_v3.query_timestamp_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param selector text +--! @return public.eql_v3_text_search +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search, selector text) +RETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. ---! @param a eql_v3.query_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param selector integer +--! @return public.eql_v3_text_search +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search, selector integer) +RETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b eql_v3.query_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a jsonb +--! @param selector public.eql_v3_text_search +--! @return public.eql_v3_text_search +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_search) +RETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a jsonb +--! @param selector public.eql_v3_text_search +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_search) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b text --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_search, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. ---! @param a eql_v3.query_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_search, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b eql_v3.query_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_search, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. ---! @param a eql_v3.query_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_search, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b eql_v3.query_timestamp_ord_ope +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope) +CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. ---! @param a eql_v3.query_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b eql_v3.query_timestamp_ord_ope +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a jsonb +--! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope) +CREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search) @> eql_v3.match_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. ---! @param a eql_v3.query_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_search, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_search, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_search, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_search, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b public.eql_v3_text_search +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search, b public.eql_v3_text_search) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @param a jsonb +--! @param b public.eql_v3_text_search +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_search) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/timestamp/query_timestamp_eq_functions.sql ---! @brief Functions for eql_v3.query_timestamp_eq. +--! @file encrypted_domain/text/text_search_ore_functions.sql +--! @brief Functions for public.eql_v3_text_search_ore. ---! @brief Index extractor for eql_v3.query_timestamp_eq. ---! @param a eql_v3.query_timestamp_eq +--! @brief Index extractor for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore --! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_timestamp_eq) +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_search_ore) RETURNS eql_v3_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b eql_v3.query_timestamp_eq +--! @brief Index extractor for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_text_search_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Index extractor for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @return eql_v3_internal.bloom_filter +CREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_search_ore) +RETURNS eql_v3_internal.bloom_filter +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; + +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b public.eql_v3_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b eql_v3.query_timestamp_eq) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_eq. ---! @param a eql_v3.query_timestamp_eq ---! @param b public.eql_v3_timestamp_eq +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_eq, b public.eql_v3_timestamp_eq) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_search_ore) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b eql_v3.query_timestamp_eq +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b eql_v3.query_timestamp_eq) +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search_ore) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_eq. ---! @param a eql_v3.query_timestamp_eq ---! @param b public.eql_v3_timestamp_eq +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b public.eql_v3_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_eq, b public.eql_v3_timestamp_eq) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; --- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_search_ore_operators.sql ---! @brief Operators for public.eql_v3_text_search_ore. +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_search_ore) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search_ore) <> eql_v3.eq_term(b) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) < eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) <= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) > eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) >= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param selector text +--! @return public.eql_v3_text_search_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search_ore, selector text) +RETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param selector integer +--! @return public.eql_v3_text_search_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search_ore, selector integer) +RETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a jsonb +--! @param selector public.eql_v3_text_search_ore +--! @return public.eql_v3_text_search_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_search_ore) +RETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a jsonb +--! @param selector public.eql_v3_text_search_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_search_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_search_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_search_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_search_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_search_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[] -); +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[] -); +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search_ore) $$; -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonpath -); +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search_ore) @> eql_v3.match_term(b) $$; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_search_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_search_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_search_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_search_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_search_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_search_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_search_operators.sql ---! @brief Operators for public.eql_v3_text_search. +--! @file encrypted_domain/text/text_ord_ore_operators.sql +--! @brief Operators for public.eql_v3_text_ord_ore. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_search, RIGHTARG = text + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_search, RIGHTARG = integer + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_search, RIGHTARG = text + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_search, RIGHTARG = integer + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_text_search, RIGHTARG = text + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_text_search, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_text_search, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_text_search, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_text_search, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_search, RIGHTARG = text + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_search, RIGHTARG = integer + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_search, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_text_search, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_ord_ore_operators.sql ---! @brief Operators for public.eql_v3_text_ord_ore. +--! @file encrypted_domain/text/text_ord_operators.sql +--! @brief Operators for public.eql_v3_text_ord. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore + LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore + LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_text_ord, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_text_ord, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_text_ord, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_text_ord, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore + LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_ord_ope_operators.sql ---! @brief Operators for public.eql_v3_text_ord_ope. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @file encrypted_domain/timestamp/timestamp_ord_ore_functions.sql +--! @brief Functions for public.eql_v3_timestamp_ord_ore. -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Index extractor for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_timestamp_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) = eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) <> eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) < eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) <= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) > eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope -); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb -); +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) >= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param selector text +--! @return public.eql_v3_timestamp_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ore, selector text) +RETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param selector integer +--! @return public.eql_v3_timestamp_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ore, selector integer) +RETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a jsonb +--! @param selector public.eql_v3_timestamp_ord_ore +--! @return public.eql_v3_timestamp_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_ord_ore) +RETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a jsonb +--! @param selector public.eql_v3_timestamp_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_ord_operators.sql ---! @brief Operators for public.eql_v3_text_ord. +--! @file encrypted_domain/timestamp/timestamp_ord_functions.sql +--! @brief Functions for public.eql_v3_timestamp_ord. + +--! @brief Index extractor for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_timestamp_ord) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param selector text +--! @return public.eql_v3_timestamp_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord, selector text) +RETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param selector integer +--! @return public.eql_v3_timestamp_ord +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord, selector integer) +RETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a jsonb +--! @param selector public.eql_v3_timestamp_ord +--! @return public.eql_v3_timestamp_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_ord) +RETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a jsonb +--! @param selector public.eql_v3_timestamp_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_operators.sql +--! @brief Operators for public.eql_v3_timestamp_ord. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_functions.sql ---! @brief Functions for public.eql_v3_text. +--! @file encrypted_domain/timestamp/query_timestamp_eq_functions.sql +--! @brief Functions for eql_v3.query_timestamp_eq. ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text +--! @brief Index extractor for eql_v3.query_timestamp_eq. +--! @param a eql_v3.query_timestamp_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_timestamp_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b eql_v3.query_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b public.eql_v3_text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b eql_v3.query_timestamp_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Operator wrapper for eql_v3.query_timestamp_eq. +--! @param a eql_v3.query_timestamp_eq +--! @param b public.eql_v3_timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_eq, b public.eql_v3_timestamp_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_eq. +--! @param a public.eql_v3_timestamp_eq +--! @param b eql_v3.query_timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b eql_v3.query_timestamp_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_eq. +--! @param a eql_v3.query_timestamp_eq +--! @param b public.eql_v3_timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_eq, b public.eql_v3_timestamp_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ope_functions.sql +--! @brief Functions for public.eql_v3_timestamp_ord_ope. + +--! @brief Index extractor for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_timestamp_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) = eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b public.eql_v3_text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) <> eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b public.eql_v3_text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b public.eql_v3_text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b public.eql_v3_text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b public.eql_v3_text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b public.eql_v3_text) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b public.eql_v3_text) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param selector text ---! @return public.eql_v3_text -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text, selector text) -RETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$ +--! @return public.eql_v3_timestamp_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ope, selector text) +RETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param selector integer ---! @return public.eql_v3_text -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text, selector integer) -RETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$ +--! @return public.eql_v3_timestamp_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ope, selector integer) +RETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. --! @param a jsonb ---! @param selector public.eql_v3_text ---! @return public.eql_v3_text -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text) -RETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$ +--! @param selector public.eql_v3_timestamp_ord_ope +--! @return public.eql_v3_timestamp_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_ord_ope) +RETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. --! @param a jsonb ---! @param selector public.eql_v3_text +--! @param selector public.eql_v3_timestamp_ord_ope --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonpath +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text'; END; $$ +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text'; END; $$ +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text, b public.eql_v3_text) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text +--! @param b public.eql_v3_timestamp_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/query_text_search_ore_functions.sql ---! @brief Functions for eql_v3.query_text_search_ore. +--! @file encrypted_domain/timestamp/timestamp_ord_ope_operators.sql +--! @brief Operators for public.eql_v3_timestamp_ord_ope. ---! @brief Index extractor for eql_v3.query_text_search_ore. ---! @param a eql_v3.query_text_search_ore ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_search_ore) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Index extractor for eql_v3.query_text_search_ore. ---! @param a eql_v3.query_text_search_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_text_search_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Index extractor for eql_v3.query_text_search_ore. ---! @param a eql_v3.query_text_search_ore ---! @return eql_v3_internal.bloom_filter -CREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_search_ore) -RETURNS eql_v3_internal.bloom_filter -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b eql_v3.query_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a eql_v3.query_text_search_ore ---! @param b public.eql_v3_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b eql_v3.query_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a eql_v3.query_text_search_ore ---! @param b public.eql_v3_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b eql_v3.query_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a eql_v3.query_text_search_ore ---! @param b public.eql_v3_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b eql_v3.query_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a eql_v3.query_text_search_ore ---! @param b public.eql_v3_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b eql_v3.query_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a eql_v3.query_text_search_ore ---! @param b public.eql_v3_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b eql_v3.query_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a eql_v3.query_text_search_ore ---! @param b public.eql_v3_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b eql_v3.query_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.contains(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a eql_v3.query_text_search_ore ---! @param b public.eql_v3_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b eql_v3.query_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a eql_v3.query_text_search_ore ---! @param b public.eql_v3_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope +); ---! @file encrypted_domain/text/query_text_search_functions.sql ---! @brief Functions for eql_v3.query_text_search. +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb +); ---! @brief Index extractor for eql_v3.query_text_search. ---! @param a eql_v3.query_text_search ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_search) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope +); ---! @brief Index extractor for eql_v3.query_text_search. ---! @param a eql_v3.query_text_search ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_search) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope +); ---! @brief Index extractor for eql_v3.query_text_search. ---! @param a eql_v3.query_text_search ---! @return eql_v3_internal.bloom_filter -CREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_search) -RETURNS eql_v3_internal.bloom_filter -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb +); ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a public.eql_v3_text_search ---! @param b eql_v3.query_text_search ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b eql_v3.query_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope +); ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a eql_v3.query_text_search ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_search, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text +); ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a public.eql_v3_text_search ---! @param b eql_v3.query_text_search ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b eql_v3.query_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer +); ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a eql_v3.query_text_search ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_search, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope +); ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a public.eql_v3_text_search ---! @param b eql_v3.query_text_search ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b eql_v3.query_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text +); ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a eql_v3.query_text_search ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_search, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer +); ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a public.eql_v3_text_search ---! @param b eql_v3.query_text_search ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b eql_v3.query_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope +); ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a eql_v3.query_text_search ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_search, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text +); ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a public.eql_v3_text_search ---! @param b eql_v3.query_text_search ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b eql_v3.query_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a eql_v3.query_text_search ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_search, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a public.eql_v3_text_search ---! @param b eql_v3.query_text_search ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b eql_v3.query_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonpath +); ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a eql_v3.query_text_search ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_search, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope +); ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a public.eql_v3_text_search ---! @param b eql_v3.query_text_search ---! @return boolean -CREATE FUNCTION eql_v3.contains(a public.eql_v3_text_search, b eql_v3.query_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb +); ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a eql_v3.query_text_search ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.query_text_search, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope +); ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a public.eql_v3_text_search ---! @param b eql_v3.query_text_search ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_search, b eql_v3.query_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonpath +); ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a eql_v3.query_text_search ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.query_text_search, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/query_text_ord_ore_functions.sql ---! @brief Functions for eql_v3.query_text_ord_ore. - ---! @brief Index extractor for eql_v3.query_text_ord_ore. ---! @param a eql_v3.query_text_ord_ore ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord_ore) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Index extractor for eql_v3.query_text_ord_ore. ---! @param a eql_v3.query_text_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_text_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b eql_v3.query_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ore. ---! @param a eql_v3.query_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b eql_v3.query_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ore. ---! @param a eql_v3.query_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b eql_v3.query_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ore. ---! @param a eql_v3.query_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b eql_v3.query_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ore. ---! @param a eql_v3.query_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b eql_v3.query_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ore. ---! @param a eql_v3.query_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b eql_v3.query_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ore. ---! @param a eql_v3.query_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/query_text_ord_functions.sql ---! @brief Functions for eql_v3.query_text_ord. - ---! @brief Index extractor for eql_v3.query_text_ord. ---! @param a eql_v3.query_text_ord ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Index extractor for eql_v3.query_text_ord. ---! @param a eql_v3.query_text_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_ord) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b eql_v3.query_text_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b eql_v3.query_text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord. ---! @param a eql_v3.query_text_ord ---! @param b public.eql_v3_text_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord, b public.eql_v3_text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b eql_v3.query_text_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b eql_v3.query_text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord. ---! @param a eql_v3.query_text_ord ---! @param b public.eql_v3_text_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord, b public.eql_v3_text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b eql_v3.query_text_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b eql_v3.query_text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord. ---! @param a eql_v3.query_text_ord ---! @param b public.eql_v3_text_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord, b public.eql_v3_text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b eql_v3.query_text_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b eql_v3.query_text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord. ---! @param a eql_v3.query_text_ord ---! @param b public.eql_v3_text_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord, b public.eql_v3_text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b eql_v3.query_text_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b eql_v3.query_text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord. ---! @param a eql_v3.query_text_ord ---! @param b public.eql_v3_text_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord, b public.eql_v3_text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b eql_v3.query_text_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b eql_v3.query_text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord. ---! @param a eql_v3.query_text_ord ---! @param b public.eql_v3_text_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord, b public.eql_v3_text_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/query_text_ord_ope_functions.sql ---! @brief Functions for eql_v3.query_text_ord_ope. - ---! @brief Index extractor for eql_v3.query_text_ord_ope. ---! @param a eql_v3.query_text_ord_ope ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord_ope) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Index extractor for eql_v3.query_text_ord_ope. ---! @param a eql_v3.query_text_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b eql_v3.query_text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ope. ---! @param a eql_v3.query_text_ord_ope ---! @param b public.eql_v3_text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b eql_v3.query_text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ope. ---! @param a eql_v3.query_text_ord_ope ---! @param b public.eql_v3_text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b eql_v3.query_text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ope. ---! @param a eql_v3.query_text_ord_ope ---! @param b public.eql_v3_text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b eql_v3.query_text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ope. ---! @param a eql_v3.query_text_ord_ope ---! @param b public.eql_v3_text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b eql_v3.query_text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ope. ---! @param a eql_v3.query_text_ord_ope ---! @param b public.eql_v3_text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b eql_v3.query_text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_ord_ope. ---! @param a eql_v3.query_text_ord_ope ---! @param b public.eql_v3_text_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/query_text_match_functions.sql ---! @brief Functions for eql_v3.query_text_match. - ---! @brief Index extractor for eql_v3.query_text_match. ---! @param a eql_v3.query_text_match ---! @return eql_v3_internal.bloom_filter -CREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_match) -RETURNS eql_v3_internal.bloom_filter -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.query_text_match. ---! @param a public.eql_v3_text_match ---! @param b eql_v3.query_text_match ---! @return boolean -CREATE FUNCTION eql_v3.contains(a public.eql_v3_text_match, b eql_v3.query_text_match) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_match. ---! @param a eql_v3.query_text_match ---! @param b public.eql_v3_text_match ---! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.query_text_match, b public.eql_v3_text_match) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_text_match. ---! @param a public.eql_v3_text_match ---! @param b eql_v3.query_text_match ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_match, b eql_v3.query_text_match) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_text_match. ---! @param a eql_v3.query_text_match ---! @param b public.eql_v3_text_match ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.query_text_match, b public.eql_v3_text_match) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text +); ---! @file encrypted_domain/text/query_text_eq_functions.sql ---! @brief Functions for eql_v3.query_text_eq. +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer +); ---! @brief Index extractor for eql_v3.query_text_eq. ---! @param a eql_v3.query_text_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b eql_v3.query_text_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b eql_v3.query_text_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_text_eq. ---! @param a eql_v3.query_text_eq ---! @param b public.eql_v3_text_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_eq, b public.eql_v3_text_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope +); ---! @brief Operator wrapper for eql_v3.query_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b eql_v3.query_text_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b eql_v3.query_text_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb +); ---! @brief Operator wrapper for eql_v3.query_text_eq. ---! @param a eql_v3.query_text_eq ---! @param b public.eql_v3_text_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_eq, b public.eql_v3_text_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope +); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/smallint/smallint_ord_ore_operators.sql ---! @brief Operators for public.eql_v3_smallint_ord_ore. +--! @file encrypted_domain/timestamp/timestamp_ord_ore_operators.sql +--! @brief Operators for public.eql_v3_timestamp_ord_ore. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/smallint_ord_ope_operators.sql ---! @brief Operators for public.eql_v3_smallint_ord_ope. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore ); -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @file v3/json/types.sql +--! @brief Domain types for the eql_v3 encrypted-JSONB (SteVec) surface. +--! +--! Three jsonb-backed domains (none over another domain — operators resolve +--! against the ultimate base type jsonb, so the native-jsonb firewall in +--! blockers.sql can attach): +--! - public.eql_v3_json_search — storage/root: an EQL envelope object ({i, v, ...}). +--! - public.eql_v3_json_entry — a single sv element (returned by `->`). +--! - eql_v3.query_json — a containment needle (sv elements, no ciphertext). -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Validate a single SteVec entry payload. +--! @internal +--! @param val jsonb Candidate entry payload. +--! @return boolean True when `val` is an sv entry with string `s`, string `c`, +--! and exactly one string deterministic term (`hm` XOR `op`). +CREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_entry_payload(val jsonb) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT COALESCE( + jsonb_typeof(val) = 'object' + AND jsonb_typeof(val -> 's') = 'string' + AND jsonb_typeof(val -> 'c') = 'string' + AND ( + (jsonb_typeof(val -> 'hm') = 'string' AND NOT (val ? 'op')) + OR + (jsonb_typeof(val -> 'op') = 'string' AND NOT (val ? 'hm')) + ), + false + ) +$$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Validate a SteVec containment query payload. +--! @internal +--! @param val jsonb Candidate query payload. +--! @return boolean True when `val` is `{"sv":[...]}` and every element carries +--! string `s`, no ciphertext, and exactly one string term (`hm` XOR +--! `op`). +--! @note plpgsql, not LANGUAGE sql (issues #353/#354): the only caller is the +--! eql_v3.query_json domain CHECK, where a SQL function can never be +--! inlined (and the CHECK itself cannot absorb this body — it needs a +--! subquery over the sv elements, which CHECK constraints forbid). plpgsql +--! caches its plan across calls instead of paying the per-call SQL-function +--! executor on every needle cast. +CREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_query_payload(val jsonb) + RETURNS boolean + LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +AS $$ +BEGIN + RETURN COALESCE( + jsonb_typeof(val) = 'object' + AND jsonb_typeof(val -> 'sv') = 'array' + AND NOT EXISTS ( + SELECT 1 + FROM jsonb_array_elements( + CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END + ) AS elem + WHERE NOT COALESCE(( + jsonb_typeof(elem) = 'object' + AND jsonb_typeof(elem -> 's') = 'string' + AND NOT (elem ? 'c') + AND ( + (jsonb_typeof(elem -> 'hm') = 'string' AND NOT (elem ? 'op')) + OR + (jsonb_typeof(elem -> 'op') = 'string' AND NOT (elem ? 'hm')) + ) + ), false) + ), + false + ); +END; +$$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Validate a root SteVec document payload. +--! @internal +--! @param val jsonb Candidate document payload. +--! @return boolean True when `val` is an encrypted document envelope with +--! `v = 3`, `i`, an `sv` array, and valid sv entry elements. +CREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_document_payload(val jsonb) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT COALESCE( + jsonb_typeof(val) = 'object' + AND val ? 'v' + AND val ->> 'v' = '3' + AND val ? 'i' + AND jsonb_typeof(val -> 'sv') = 'array' + AND NOT EXISTS ( + SELECT 1 + FROM jsonb_array_elements( + CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END + ) AS elem + WHERE NOT public.eql_v3_is_valid_ste_vec_entry_payload(elem) + ), + false + ) +$$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Storage/root domain for an encrypted JSONB column. +--! +--! CHECK: a JSON object carrying the EQL envelope (`v = 3` version and `i` index +--! metadata). Root `c` is intentionally NOT required — an sv-array root payload +--! is `{i, v, sv}` with no root ciphertext. The CHECK now also requires an `sv` +--! array, so the domain accepts only SteVec **document** payloads and rejects +--! encrypted *scalar* payloads (which carry `c`/`hm`/`ob` but no `sv`) — this is +--! what keeps `public.eql_v3_json_search` a typed document domain rather than a generic +--! encrypted envelope. The firewall in blockers.sql attaches to this domain to +--! stop native jsonb operators from reaching a column value. +--! +--! @note Constructing from inline JSON uses the standard DOMAIN cast: +--! `'{"i":{},"v":3,"sv":[...]}'::public.eql_v3_json_search`. +DO $$ +BEGIN + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'eql_v3_json_search' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.eql_v3_json_search AS jsonb + CHECK ( + public.eql_v3_is_valid_ste_vec_document_payload(VALUE) + ); + END IF; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); + COMMENT ON DOMAIN public.eql_v3_json_search IS 'EQL encrypted JSONB searchable document (containment)'; +END +$$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Domain type for an individual sv element. +--! +--! A single element inside an `sv` array: a JSON object that carries a selector +--! (`s`), a ciphertext (`c`), and **exactly one** of `hm` (HMAC-256, for +--! hash-equality) or `op` (CLLW OPE, for ordered queries) — they are mutually +--! exclusive. This is the type returned by `->` and accepted by the per-entry +--! extractors `eql_v3.eq_term` / `eql_v3.ord_term`. Extra fields (`a`, root +--! `i`/`v` merged in by `->`) are allowed. +--! +--! @see src/v3/json/operators.sql +--! +--! @internal +--! Implementation note (issue #354): the CHECK is an INLINE expression, not a +--! call to `public.eql_v3_is_valid_ste_vec_entry_payload` — domain +--! constraints cannot inline SQL functions, so the function-call form paid +--! the per-call SQL-function executor (~18 µs) on EVERY cast: the needle +--! cast in every field_eq query (+19% end-to-end vs v2, the entire measured +--! regression on that scenario; see cipherstash/benches#23). The expression +--! mirrors the validator body; the leading `VALUE IS NULL OR` preserves the +--! validator's STRICT NULL-passes semantics (a bare COALESCE(..., false) +--! would reject NULL, which `->` returns for a missing selector). Keep the +--! two in sync — `jsonb_entry_check_matches_validator` in tests/sqlx pins +--! the equivalence. +--! @endinternal +DO $$ +BEGIN + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'eql_v3_json_entry' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.eql_v3_json_entry AS jsonb + CHECK ( + VALUE IS NULL + OR COALESCE( + jsonb_typeof(VALUE) = 'object' + AND jsonb_typeof(VALUE -> 's') = 'string' + AND jsonb_typeof(VALUE -> 'c') = 'string' + AND ( + (jsonb_typeof(VALUE -> 'hm') = 'string' AND NOT (VALUE ? 'op')) + OR + (jsonb_typeof(VALUE -> 'op') = 'string' AND NOT (VALUE ? 'hm')) + ), + false + ) + ); + END IF; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); + COMMENT ON DOMAIN public.eql_v3_json_entry IS 'EQL encrypted JSONB leaf entry (equality, ordering)'; +END +$$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Domain type for an STE-vec containment needle. +--! +--! A query-shaped payload `{"sv":[...]}` whose elements carry selector + index +--! term but **never** a ciphertext (`c`). Each element must carry `s` and +--! exactly one deterministic term (`hm` XOR `op`). Typing the needle this way +--! stops selector-only needles from casting and matching every row via bare +--! `jsonb @>`. +--! +--! @note Construct from inline JSON via the DOMAIN cast: +--! `'{"sv":[{"s":"","hm":""}]}'::eql_v3.query_json`. +--! @see eql_v3.to_ste_vec_query +--! +--! @internal +--! Implementation note (issue #354): this CHECK CANNOT be inlined like +--! public.eql_v3_json_entry's — validating the sv elements requires a subquery +--! (`NOT EXISTS (SELECT ... FROM jsonb_array_elements(...))`), and CHECK +--! constraints forbid subqueries. The validator is plpgsql instead (cached +--! plan; substantially cheaper per call than a non-inlined LANGUAGE sql +--! function — the same finding as issue #353), since this cast sits on the +--! per-query hot path of every containment scenario +--! (`$1::jsonb::eql_v3.query_json`). +--! @endinternal +DO $$ +BEGIN + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'query_json' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.query_json AS jsonb + CHECK ( + public.eql_v3_is_valid_ste_vec_query_payload(VALUE) + ); + END IF; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); + COMMENT ON DOMAIN eql_v3.query_json IS 'EQL JSONB query operand (containment)'; +END +$$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Convert a public.eql_v3_json_search to a query_json needle. +--! +--! Normalises each sv element down to the matching-relevant fields: `s` plus +--! exactly one of `hm` / `op`. Other fields (`c`, `a`, `i`/`v`, anything else) +--! are stripped. This is the canonical needle shape for `@>` containment. +--! Designed for use as a functional GIN index expression: +--! `GIN (eql_v3.to_ste_vec_query(col)::jsonb jsonb_path_ops)`. +--! +--! @param e public.eql_v3_json_search Source encrypted payload +--! @return eql_v3.query_json Query-shaped needle, sv elements normalised. +--! @see eql_v3.query_json +CREATE FUNCTION eql_v3.to_ste_vec_query(e public.eql_v3_json_search) + RETURNS eql_v3.query_json + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT jsonb_build_object( + 'sv', + coalesce( + (SELECT jsonb_agg( + jsonb_strip_nulls( + jsonb_build_object( + 's', elem -> 's', + 'hm', elem -> 'hm', + 'op', elem -> 'op' + ) + ) + ) + FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem), + '[]'::jsonb + ) + )::eql_v3.query_json +$$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +CREATE CAST (public.eql_v3_json_search AS eql_v3.query_json) + WITH FUNCTION eql_v3.to_ste_vec_query + AS ASSIGNMENT; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @file v3/json/functions.sql +--! @brief Extractors, containment engine, and path/array functions for the +--! eql_v3 encrypted-JSONB (SteVec) surface. +--! +--! `selector` parameters here are *encrypted-side* selector hashes — the +--! deterministic hash the crypto layer emits in the `s` field of each sv +--! element. Plaintext JSONPaths are never accepted at runtime. -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +------------------------------------------------------------------------------ +-- Envelope helpers (eql_v3 owns these; jsonb-only) +------------------------------------------------------------------------------ -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Extract metadata (i, v) from a raw jsonb encrypted value. +--! @param val jsonb encrypted EQL payload +--! @return jsonb Metadata object with `i` and `v` fields. +CREATE FUNCTION eql_v3.meta_data(val jsonb) + RETURNS jsonb + IMMUTABLE STRICT PARALLEL SAFE + LANGUAGE SQL +AS $$ + SELECT jsonb_build_object('i', val->'i', 'v', val->'v'); +$$; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope -); +COMMENT ON FUNCTION eql_v3.meta_data(jsonb) IS + 'eql-inline-critical: raw-jsonb envelope helper used by v3 jsonb wrappers; must stay inlinable (unpinned search_path)'; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb -); +--! @brief Extract ciphertext (c) from a raw jsonb encrypted value. +--! @param val jsonb encrypted EQL payload +--! @return text Base64-encoded ciphertext. +--! @throws Exception if `c` is absent. +CREATE FUNCTION eql_v3.ciphertext(val jsonb) + RETURNS text + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + BEGIN + IF val ? 'c' THEN + RETURN val->>'c'; + END IF; + RAISE 'Expected a ciphertext (c) value in json: %', val; + END; +$$ LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope -); +------------------------------------------------------------------------------ +-- Selector extractors +------------------------------------------------------------------------------ -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope -); +--! @brief Extract selector (s) from a raw jsonb encrypted value. +--! @param val jsonb encrypted EQL payload +--! @return text The selector value. +--! @throws Exception if `s` is absent. +CREATE FUNCTION eql_v3.selector(val jsonb) + RETURNS text + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + BEGIN + IF val ? 's' THEN + RETURN val->>'s'; + END IF; + RAISE 'Expected a selector index (s) value in json: %', val; + END; +$$ LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb -); +--! @brief Extract selector (s) from a ste_vec entry. The DOMAIN CHECK +--! guarantees `s` is present, so this is a simple field access. +--! @param entry public.eql_v3_json_entry +--! @return text The selector value. +CREATE FUNCTION eql_v3.selector(entry public.eql_v3_json_entry) + RETURNS text + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT entry ->> 's' +$$; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope -); +------------------------------------------------------------------------------ +-- Equality-term extractor (XOR-aware: coalesce(hm, op)) +------------------------------------------------------------------------------ -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text -); +--! @brief XOR-aware equality term extractor for public.eql_v3_json_entry. +--! +--! Returns the bytea of whichever deterministic term the sv entry carries — +--! `hm` (HMAC-256) or `op` (CLLW OPE). The two byte distributions are disjoint +--! by construction, so byte equality on the coalesce is unambiguous. Canonical +--! equality extractor used by `=` / `<>` on jsonb_entry. +--! +--! @param entry public.eql_v3_json_entry +--! @return bytea Decoded `hm` or `op` bytes (NULL if entry is NULL). +CREATE FUNCTION eql_v3.eq_term(entry public.eql_v3_json_entry) + RETURNS bytea + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT decode(coalesce(entry ->> 'hm', entry ->> 'op'), 'hex') +$$; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer -); +------------------------------------------------------------------------------ +-- CLLW OPE per-entry overload (converged with the scalar ord_term) +------------------------------------------------------------------------------ -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope -); +--! @brief Extract the CLLW OPE index term from a ste_vec entry. +--! +--! An sv-element `op` term is only ever present on an sv element, never at a +--! root encrypted value, so the typed overload accepts public.eql_v3_json_entry — +--! the jsonb_entry twin of the generated scalar `eql_v3.ord_term` +--! extractors. Returns SQL NULL when `op` is absent (the strict `->>` / +--! `decode` chain propagates it), so btree NULL-filters such rows from range +--! queries. The returned eql_v3_internal.ope_cllw is a bytea domain: it orders +--! under native byte comparison with the DEFAULT btree opclass, so a +--! functional index on `eql_v3.ord_term(col -> 'selector')` engages +--! structurally with no custom operator class (Supabase/managed-Postgres +--! safe). +--! +--! @param entry public.eql_v3_json_entry +--! @return eql_v3_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when +--! `op` is absent. +CREATE FUNCTION eql_v3.ord_term(entry public.eql_v3_json_entry) + RETURNS eql_v3_internal.ope_cllw + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.ope_cllw(entry::jsonb) +$$; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text -); +------------------------------------------------------------------------------ +-- sv-array helpers +------------------------------------------------------------------------------ -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer -); +--! @brief Extract the sv element array as raw jsonb[]. +--! +--! Returns the elements of `sv` (or a single-element array wrapping the value +--! when there is no `sv`). No envelope re-wrapping — raw jsonb elements. +--! +--! @param val jsonb encrypted EQL payload +--! @return jsonb[] Array of sv elements. +CREATE FUNCTION eql_v3.ste_vec(val jsonb) + RETURNS jsonb[] + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + sv jsonb; + ary jsonb[]; + BEGIN + IF val ? 'sv' THEN + sv := val->'sv'; + ELSE + sv := jsonb_build_array(val); + END IF; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope -); + SELECT array_agg(elem) + INTO ary + FROM jsonb_array_elements(sv) AS elem; -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text -); + RETURN ary; + END; +$$ LANGUAGE plpgsql; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[] -); +--! @brief Check if a jsonb payload is marked as an sv array (`a` flag true). +--! @param val jsonb encrypted EQL payload +--! @return boolean True if `a` is present and true. +CREATE FUNCTION eql_v3_internal.is_ste_vec_array(val jsonb) + RETURNS boolean + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + BEGIN + IF val ? 'a' THEN + RETURN (val->>'a')::boolean; + END IF; + RETURN false; + END; +$$ LANGUAGE plpgsql; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[] -); +------------------------------------------------------------------------------ +-- Deterministic-fields array for GIN containment +------------------------------------------------------------------------------ -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonpath -); +--! @brief Extract deterministic search fields (s, hm, op) per sv element. +--! +--! Excludes non-deterministic ciphertext so PostgreSQL's native jsonb `@>` can +--! compare for containment. Use for GIN indexes and containment queries. +--! +--! @param val jsonb encrypted EQL payload +--! @return jsonb[] Array of objects with only deterministic fields. +CREATE FUNCTION eql_v3.jsonb_array(val jsonb) +RETURNS jsonb[] +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE SQL +AS $$ + SELECT ARRAY( + SELECT jsonb_object_agg(kv.key, kv.value) + FROM jsonb_array_elements( + CASE WHEN val ? 'sv' THEN val->'sv' ELSE jsonb_build_array(val) END + ) AS elem, + LATERAL jsonb_each(elem) AS kv(key, value) + WHERE kv.key IN ('s', 'hm', 'op') + GROUP BY elem + ); +$$; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonpath -); +COMMENT ON FUNCTION eql_v3.jsonb_array(jsonb) IS + 'eql-inline-critical: raw-jsonb deterministic-field array helper; must stay inlinable (unpinned search_path)'; -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[] -); +------------------------------------------------------------------------------ +-- Containment +------------------------------------------------------------------------------ -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[] -); +--! @brief GIN-indexable containment check: does `a` contain all of `b`? +--! @param a jsonb Container payload. +--! @param b jsonb Search payload. +--! @return boolean True if a contains all deterministic elements of b. +--! @note Public raw-`jsonb[]` containment helper over the extracted +--! deterministic fields — the function-form entrypoint for containment on +--! platforms without operator support (Supabase/PostgREST). The typed +--! `public.eql_v3_json_search` `@>` operator does NOT call this function — it binds to +--! `eql_v3.ste_vec_contains` instead — but both agree on the result (a +--! parity test pins this). Also the documented GIN index expression +--! (`eql_v3.jsonb_array(col)`); see docs/reference/database-indexes.md. +CREATE FUNCTION eql_v3.jsonb_contains(a jsonb, b jsonb) +RETURNS boolean +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE SQL +AS $$ + SELECT eql_v3.jsonb_array(a) @> eql_v3.jsonb_array(b); +$$; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text -); +COMMENT ON FUNCTION eql_v3.jsonb_contains(jsonb, jsonb) IS + 'eql-inline-critical: raw-jsonb containment helper; must stay inlinable (unpinned search_path)'; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer -); +--! @brief GIN-indexable "is contained by" check. +--! @param a jsonb Payload to check. +--! @param b jsonb Container payload. +--! @return boolean True if all elements of a are contained in b. +--! @note Public raw-`jsonb[]` reverse-containment helper — the function-form +--! entrypoint for `<@` on platforms without operator support. The typed +--! `public.eql_v3_json_search` `<@` operator binds to `eql_v3.ste_vec_contains` instead, +--! but both agree on the result. +CREATE FUNCTION eql_v3.jsonb_contained_by(a jsonb, b jsonb) +RETURNS boolean +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE SQL +AS $$ + SELECT eql_v3.jsonb_array(a) <@ eql_v3.jsonb_array(b); +$$; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[] -); +COMMENT ON FUNCTION eql_v3.jsonb_contained_by(jsonb, jsonb) IS + 'eql-inline-critical: raw-jsonb contained-by helper; must stay inlinable (unpinned search_path)'; -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[] -); +--! @brief Check if an sv array contains a specific sv element. +--! +--! Match = selector equal AND eq_term equal (byte-equality over coalesce(hm, +--! op)). This collapses the v2 hm/oc CASE: under the XOR contract both terms +--! are deterministic and byte-disjoint, so either one is a valid equality +--! discriminator and a single byte comparison is correct. +--! +--! ASSUMPTION (locked by a negative test in v3_jsonb_tests.rs): hm and op byte +--! distributions never collide at a given selector. The crypto layer configures +--! a selector for eq XOR ordered, so both sides of a real comparison carry the +--! same term type — an hm needle never meets an op leaf at the same selector. +--! This collapse would wrongly match an hm needle against an op leaf if their +--! hex bytes were ever identical — which the contract prevents (an hm is a +--! fixed 32-byte HMAC; an op is a CLLW OPE ciphertext whose length is a +--! function of the plaintext bit width, never 32 bytes for the supported +--! domains). The negative-containment test guards against regression. +--! +--! @param a jsonb[] sv array to search within. +--! @param b jsonb sv element to search for. +--! @return boolean True if b is found in any element of a. +CREATE FUNCTION eql_v3.ste_vec_contains(a jsonb[], b jsonb) + RETURNS boolean + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + result boolean; + _a jsonb; + BEGIN + result := false; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope -); + FOR idx IN 1..array_length(a, 1) LOOP + _a := a[idx]; + result := result OR ( + eql_v3.selector(_a) = eql_v3.selector(b) + AND eql_v3.eq_term(_a::public.eql_v3_json_entry) = eql_v3.eq_term(b::public.eql_v3_json_entry) + ); + EXIT WHEN result; + END LOOP; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb -); + RETURN result; + END; +$$ LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Does encrypted value `a` contain all sv elements of `b`? +--! +--! Empty b is always contained. Each element of b must match selector + eq_term +--! in some element of a. +--! +--! @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. +--! @see eql_v3.ste_vec_contains(jsonb[], jsonb) +CREATE FUNCTION eql_v3.ste_vec_contains(a public.eql_v3_json_search, b public.eql_v3_json_search) + RETURNS boolean + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + result boolean; + sv_a jsonb[]; + sv_b jsonb[]; + _b jsonb; + BEGIN + sv_a := eql_v3.ste_vec(a); + sv_b := eql_v3.ste_vec(b); ---! @file encrypted_domain/smallint/smallint_ord_operators.sql ---! @brief Operators for public.eql_v3_smallint_ord. + IF array_length(sv_b, 1) IS NULL THEN + RETURN true; + END IF; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); + IF array_length(sv_a, 1) IS NULL THEN + RETURN false; + END IF; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); + result := true; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); + FOR idx IN 1..array_length(sv_b, 1) LOOP + _b := sv_b[idx]; + result := result AND eql_v3.ste_vec_contains(sv_a, _b); + END LOOP; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); + RETURN result; + END; +$$ LANGUAGE plpgsql; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +------------------------------------------------------------------------------ +-- Path queries (text selector only) +------------------------------------------------------------------------------ -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Query encrypted JSONB for sv elements matching `selector`. +--! +--! Returns one jsonb_entry row per matching encrypted element. Returns empty +--! set on no match. It deliberately does not wrap multiple matches as an +--! public.eql_v3_json_search document, because the root document domain requires an `sv` +--! array and single leaves belong to public.eql_v3_json_entry. +--! +--! @param val jsonb encrypted EQL payload with `sv`. +--! @param selector text Selector hash (`s` value). +--! @return SETOF public.eql_v3_json_entry Matching encrypted entries. +--! @see eql_v3.jsonb_path_query_first +CREATE FUNCTION eql_v3.jsonb_path_query(val jsonb, selector text) + RETURNS SETOF public.eql_v3_json_entry + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_entry + FROM jsonb_array_elements(val -> 'sv') elem + WHERE elem ->> 's' = selector +$$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +COMMENT ON FUNCTION eql_v3.jsonb_path_query(jsonb, text) IS + 'eql-inline-critical: raw-jsonb path query helper; must stay inlinable (unpinned search_path)'; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Check if a selector path exists in encrypted JSONB. +--! @param val jsonb encrypted EQL payload. +--! @param selector text Selector hash to test. +--! @return boolean True if a matching element exists. +CREATE FUNCTION eql_v3.jsonb_path_exists(val jsonb, selector text) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT EXISTS ( + SELECT 1 FROM jsonb_array_elements(val -> 'sv') elem + WHERE elem ->> 's' = selector + ); +$$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +COMMENT ON FUNCTION eql_v3.jsonb_path_exists(jsonb, text) IS + 'eql-inline-critical: raw-jsonb path exists helper; must stay inlinable (unpinned search_path)'; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Get the first sv element matching `selector`, or NULL. +--! @param val jsonb encrypted EQL payload. +--! @param selector text Selector hash to match. +--! @return public.eql_v3_json_entry First matching element or NULL. +CREATE FUNCTION eql_v3.jsonb_path_query_first(val jsonb, selector text) + RETURNS public.eql_v3_json_entry + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_entry + FROM jsonb_array_elements(val -> 'sv') elem + WHERE elem ->> 's' = selector + LIMIT 1 +$$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +COMMENT ON FUNCTION eql_v3.jsonb_path_query_first(jsonb, text) IS + 'eql-inline-critical: raw-jsonb path first helper; must stay inlinable (unpinned search_path)'; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +------------------------------------------------------------------------------ +-- Array functions +------------------------------------------------------------------------------ -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Get the length of an encrypted JSONB array. +--! @param val jsonb encrypted EQL payload (must have `a` flag true). +--! @return integer Number of elements. +--! @throws Exception 'cannot get array length of a non-array' if not an array. +CREATE FUNCTION eql_v3.jsonb_array_length(val jsonb) + RETURNS integer + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + sv jsonb[]; + BEGIN + IF eql_v3_internal.is_ste_vec_array(val) THEN + sv := eql_v3.ste_vec(val); + RETURN array_length(sv, 1); + END IF; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); + RAISE 'cannot get array length of a non-array'; + END; +$$ LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Extract elements of an encrypted JSONB array as rows. +--! @param val jsonb encrypted EQL payload (must have `a` flag true). +--! @return SETOF public.eql_v3_json_entry One row per element (metadata preserved). +--! @throws Exception 'cannot extract elements from non-array' if not an array. +CREATE FUNCTION eql_v3.jsonb_array_elements(val jsonb) + RETURNS SETOF public.eql_v3_json_entry + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + sv jsonb[]; + meta jsonb; + item jsonb; + BEGIN + IF NOT eql_v3_internal.is_ste_vec_array(val) THEN + RAISE 'cannot extract elements from non-array'; + END IF; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); + meta := eql_v3.meta_data(val); + sv := eql_v3.ste_vec(val); -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); + FOR idx IN 1..array_length(sv, 1) LOOP + item = sv[idx]; + RETURN NEXT (meta || item)::public.eql_v3_json_entry; + END LOOP; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); + RETURN; + END; +$$ LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord -); +--! @brief Extract elements of an encrypted JSONB array as ciphertext text. +--! @param val jsonb encrypted EQL payload (must have `a` flag true). +--! @return SETOF text One ciphertext per element. +--! @throws Exception 'cannot extract elements from non-array' if not an array. +CREATE FUNCTION eql_v3.jsonb_array_elements_text(val jsonb) + RETURNS SETOF text + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + sv jsonb[]; + BEGIN + IF NOT eql_v3_internal.is_ste_vec_array(val) THEN + RAISE 'cannot extract elements from non-array'; + END IF; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb -); + sv := eql_v3.ste_vec(val); -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord -); + FOR idx IN 1..array_length(sv, 1) LOOP + RETURN NEXT eql_v3.ciphertext(sv[idx]); + END LOOP; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord -); + RETURN; + END; +$$ LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE +-- Source is src/v3/version.template -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb -); +DROP FUNCTION IF EXISTS eql_v3.version(); -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord -); +--! @file v3/version.sql +--! @brief EQL version reporting (self-contained eql_v3 surface) +--! +--! This file is auto-generated from src/v3/version.template during build. +--! The 3.0.0 placeholder is replaced with the actual release +--! version (bare semver, e.g. "3.0.0") supplied via `mise run build --version`, +--! or "DEV" for development builds. -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text -); +--! @brief Get the installed EQL version string +--! +--! Returns the version string for the installed EQL library. This value is +--! baked in at build time from the release tag. +--! +--! @return text Version string (e.g. "3.0.0" or "DEV" for development builds) +--! +--! @note Auto-generated during build from src/v3/version.template +--! +--! Example: `SELECT eql_v3.version()` returns the installed version string, +--! e.g. `'3.0.0'` (or `'DEV'` for development builds). +CREATE FUNCTION eql_v3.version() + RETURNS text + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT '3.0.0'; +$$ LANGUAGE SQL; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer -); +--! @brief Schema-level version marker for obj_description() discoverability +--! +--! Mirrors eql_v3.version() as a comment on the schema so the installed +--! version can also be read via obj_description('eql_v3'::regnamespace). +COMMENT ON SCHEMA eql_v3 IS '3.0.0'; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/smallint_functions.sql ---! @brief Functions for public.eql_v3_smallint. - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b public.eql_v3_smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b public.eql_v3_smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b public.eql_v3_smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b public.eql_v3_smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b public.eql_v3_smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b public.eql_v3_smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b public.eql_v3_smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b public.eql_v3_smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param selector text ---! @return public.eql_v3_smallint -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint, selector text) -RETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param selector integer ---! @return public.eql_v3_smallint -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint, selector integer) -RETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param selector public.eql_v3_smallint ---! @return public.eql_v3_smallint -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint) -RETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param selector public.eql_v3_smallint ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint, b public.eql_v3_smallint) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/query_smallint_ord_ore_functions.sql ---! @brief Functions for eql_v3.query_smallint_ord_ore. - ---! @brief Index extractor for eql_v3.query_smallint_ord_ore. ---! @param a eql_v3.query_smallint_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_smallint_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b eql_v3.query_smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. ---! @param a eql_v3.query_smallint_ord_ore ---! @param b public.eql_v3_smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b eql_v3.query_smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. ---! @param a eql_v3.query_smallint_ord_ore ---! @param b public.eql_v3_smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b eql_v3.query_smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. ---! @param a eql_v3.query_smallint_ord_ore ---! @param b public.eql_v3_smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b eql_v3.query_smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. ---! @param a eql_v3.query_smallint_ord_ore ---! @param b public.eql_v3_smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b eql_v3.query_smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. ---! @param a eql_v3.query_smallint_ord_ore ---! @param b public.eql_v3_smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b eql_v3.query_smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. ---! @param a eql_v3.query_smallint_ord_ore ---! @param b public.eql_v3_smallint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/query_smallint_ord_functions.sql ---! @brief Functions for eql_v3.query_smallint_ord. - ---! @brief Index extractor for eql_v3.query_smallint_ord. ---! @param a eql_v3.query_smallint_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_smallint_ord) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b eql_v3.query_smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord. ---! @param a eql_v3.query_smallint_ord ---! @param b public.eql_v3_smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b eql_v3.query_smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord. ---! @param a eql_v3.query_smallint_ord ---! @param b public.eql_v3_smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b eql_v3.query_smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord. ---! @param a eql_v3.query_smallint_ord ---! @param b public.eql_v3_smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b eql_v3.query_smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord. ---! @param a eql_v3.query_smallint_ord ---! @param b public.eql_v3_smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b eql_v3.query_smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord. ---! @param a eql_v3.query_smallint_ord ---! @param b public.eql_v3_smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b eql_v3.query_smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord. ---! @param a eql_v3.query_smallint_ord ---! @param b public.eql_v3_smallint_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/query_smallint_ord_ope_functions.sql ---! @brief Functions for eql_v3.query_smallint_ord_ope. - ---! @brief Index extractor for eql_v3.query_smallint_ord_ope. ---! @param a eql_v3.query_smallint_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_smallint_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b eql_v3.query_smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. ---! @param a eql_v3.query_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b eql_v3.query_smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. ---! @param a eql_v3.query_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b eql_v3.query_smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. ---! @param a eql_v3.query_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b eql_v3.query_smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. ---! @param a eql_v3.query_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b eql_v3.query_smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. ---! @param a eql_v3.query_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b eql_v3.query_smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. ---! @param a eql_v3.query_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/query_smallint_eq_functions.sql ---! @brief Functions for eql_v3.query_smallint_eq. - ---! @brief Index extractor for eql_v3.query_smallint_eq. ---! @param a eql_v3.query_smallint_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_smallint_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b eql_v3.query_smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b eql_v3.query_smallint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_eq. ---! @param a eql_v3.query_smallint_eq ---! @param b public.eql_v3_smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_eq, b public.eql_v3_smallint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b eql_v3.query_smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b eql_v3.query_smallint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_smallint_eq. ---! @param a eql_v3.query_smallint_eq ---! @param b public.eql_v3_smallint_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_eq, b public.eql_v3_smallint_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/real/real_ord_ore_operators.sql ---! @brief Operators for public.eql_v3_real_ord_ore. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief EQL lint: detect non-inlinable operator implementation functions +--! +--! Returns one row per violation found in the installed `eql_v3` surface. The +--! Postgres planner can only inline a function during index matching when: +--! +--! * `LANGUAGE sql` (plpgsql / C / etc. cannot be inlined) +--! * `IMMUTABLE` or `STABLE` volatility (VOLATILE cannot be inlined into +--! index expressions) +--! * No `SET` clauses (e.g. `SET search_path = ...`) +--! * Not `SECURITY DEFINER` +--! * Single-statement SELECT body +--! +--! @note The single-statement SELECT body condition is **not yet checked** by +--! this lint. A `LANGUAGE sql` function with a multi-statement body, a CTE, +--! or any pre-SELECT statement will pass all four implemented checks while +--! remaining non-inlinable. Implementing the check requires walking `prosrc` +--! (or `pg_get_functiondef`); tracked as a follow-up. +--! +--! Operators on `eql_v3` types (the jsonb-backed encrypted-domain families and +--! the SEM index-term type `eql_v3_internal.ore_block_256`) whose +--! implementation functions fail any of these rules silently fall back to seq +--! scan when the documented functional indexes (`eql_v3.eq_term(col)`, +--! `eql_v3.ord_term(col)`) are in place. This lint surfaces every such case. +--! +--! Severity: +--! `error` — fixable, blocks index matching, ship-blocking. +--! `warning` — likely-fixable, may not block matching but signals intent. +--! `info` — observational; useful for review, not a defect on its own. +--! +--! Categories: +--! `inlinability_language` — implementation function isn't `LANGUAGE sql`. +--! `inlinability_volatility` — implementation function is VOLATILE. +--! `inlinability_set_clause` — implementation function has a `SET` clause. +--! `inlinability_secdef` — implementation function is `SECURITY DEFINER`. +--! `inlinability_transitive` — implementation function is itself inlinable +--! but its body invokes a non-inlinable function +--! (depth 1; the planner can't peek through +--! that boundary). +--! `blocker_language` — encrypted-domain blocker is not LANGUAGE +--! plpgsql. The planner can inline / elide a +--! LANGUAGE sql body when the result is +--! provably unused, silently bypassing the +--! RAISE that the blocker exists to perform. +--! `blocker_strict` — encrypted-domain blocker is STRICT. +--! PostgreSQL skips the body and returns NULL +--! on NULL arguments, silently bypassing the +--! RAISE. +--! `domain_over_domain` — an `eql_v3` encrypted domain is derived from +--! another encrypted domain rather than jsonb. +--! Operators resolve against the ultimate base +--! type, so the derived domain does not +--! inherit the base domain's blocker surface. +--! `domain_opclass` — an operator class is declared FOR TYPE on an +--! `eql_v3` encrypted domain. Opclasses on +--! domains bypass operator resolution; use a +--! functional index on the extractor instead. +--! `schema_placement` — a naked composite or enum TYPE lives in the +--! public `eql_v3` schema. Internal index-term +--! types (e.g. `ore_block_256_term`) belong in +--! `eql_v3_internal`; a composite/enum in +--! `eql_v3` clutters the Supabase Table Builder +--! type picker, which the schema split exists to +--! prevent. Move it to `eql_v3_internal`. +--! +--! @example +--! ``` +--! SELECT severity, category, object_name, message +--! FROM eql_v3.lints() +--! WHERE severity = 'error' +--! ORDER BY category, object_name; +--! ``` +--! +--! @return SETOF record (severity text, category text, object_name text, message text) +CREATE OR REPLACE FUNCTION eql_v3.lints() +RETURNS TABLE ( + severity text, + category text, + object_name text, + message text +) +LANGUAGE sql STABLE +AS $$ + WITH + -- User-column encrypted domains now live in public so application tables + -- survive EQL uninstall. Keep this separate from owned_schemas(): public is + -- not installer-owned, but its EQL jsonb-backed domains are still the domain + -- types whose blockers/operator surfaces the lint must understand. + encrypted_domain_types AS ( + SELECT + dt.oid AS typid + FROM pg_catalog.pg_type dt + JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace + JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype + JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace + WHERE dt.typtype = 'd' + AND bt.typname = 'jsonb' + AND bn.nspname = 'pg_catalog' + AND ( + dn.nspname = 'public' + OR dn.nspname = ANY(eql_v3_internal.owned_schemas()) + ) + ), -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); + -- All operators where at least one operand is an EQL-owned type or a public + -- encrypted domain. Limits the scope of the lint to the operator surface + -- customers actually hit via SQL (`col = val`, `col @> '...'` and friends). + eql_operators AS ( + SELECT + op.oid AS oprid, + op.oprname AS opname, + op.oprcode AS implfunc, + op.oprleft::regtype AS lhs, + op.oprright::regtype AS rhs, + op.oprcode::regprocedure AS impl_signature + FROM pg_operator op + WHERE EXISTS ( + SELECT 1 FROM pg_type t + WHERE t.oid IN (op.oprleft, op.oprright) + AND ( + t.typnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY(eql_v3_internal.owned_schemas())) + OR t.oid IN (SELECT typid FROM encrypted_domain_types) + ) + ) + ), -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); + -- Cross-join with each operator's implementation function metadata. + -- One row per operator; columns describe the inlinability of the impl. + op_impl AS ( + SELECT + eo.opname, + eo.lhs, + eo.rhs, + eo.implfunc AS impl_oid, + eo.impl_signature::text AS impl_signature, + lang_l.lanname AS lang, + p.provolatile AS volatility, + p.proconfig AS config, + p.prosecdef AS secdef, + p.prosrc AS body + FROM eql_operators eo + JOIN pg_proc p ON p.oid = eo.implfunc + JOIN pg_language lang_l ON lang_l.oid = p.prolang + ), -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); + -- Encrypted-domain blockers: functions in `eql_v3` whose body contains + -- a blocker marker emitted by the codegen (any of the + -- `encrypted_domain_unsupported_*` helper calls — `_bool` for boolean + -- blockers, `_jsonb` for the native-jsonb-operator blockers; plus the + -- literal `is not supported for` for older path-operator blockers) AND + -- that take at least one encrypted domain over jsonb argument. The argument + -- filter excludes the shared `encrypted_domain_unsupported_*(text, text)` + -- helpers themselves, which contain the marker in their body but are not + -- blockers (they take text arguments, not a domain). + encrypted_domain_blockers AS ( + SELECT + p.oid AS oid, + p.oid::regprocedure::text AS signature, + lang_l.lanname AS lang, + p.proisstrict AS isstrict + FROM pg_catalog.pg_proc p + JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace + JOIN pg_catalog.pg_language lang_l ON lang_l.oid = p.prolang + WHERE n.nspname = ANY(eql_v3_internal.owned_schemas()) + AND (p.prosrc LIKE '%encrypted_domain_unsupported%' + OR p.prosrc LIKE '%is not supported for%') + AND EXISTS ( + SELECT 1 + FROM pg_catalog.unnest(p.proargtypes::oid[]) AS arg(typ) + JOIN encrypted_domain_types edt ON edt.typid = arg.typ + ) + ) -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ Direct inlinability checks: each row examines one operator's │ + -- │ implementation function and emits a violation if any rule is │ + -- │ broken. Multiple violations on the same function become │ + -- │ multiple rows (developers see every reason it doesn't inline). │ + -- └─────────────────────────────────────────────────────────────────┘ -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore -); + SELECT + 'error' AS severity, + 'inlinability_language' AS category, + format('operator %s(%s, %s) -> %s', + opname, lhs, rhs, impl_signature) AS object_name, + format( + '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.', + lang, opname) AS message + FROM op_impl + WHERE lang <> 'sql' + AND NOT EXISTS ( + SELECT 1 FROM encrypted_domain_blockers b + WHERE b.oid = op_impl.impl_oid + ) -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb -); + UNION ALL -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore -); + SELECT + 'error', + 'inlinability_volatility', + format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature), + format( + '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).', + opname) + FROM op_impl + WHERE volatility = 'v' + AND NOT EXISTS ( + SELECT 1 FROM encrypted_domain_blockers b + WHERE b.oid = op_impl.impl_oid + ) -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore -); + UNION ALL -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb -); + SELECT + 'error', + 'inlinability_set_clause', + format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature), + format( + '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.') + FROM op_impl + WHERE config IS NOT NULL + AND NOT EXISTS ( + SELECT 1 FROM encrypted_domain_blockers b + WHERE b.oid = op_impl.impl_oid + ) -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore -); + UNION ALL -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text -); + SELECT + 'error', + 'inlinability_secdef', + format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature), + 'Operator implementation function is `SECURITY DEFINER`. Such functions cannot be inlined; remove `SECURITY DEFINER` or use a non-inlinable wrapper layer.' + FROM op_impl + WHERE secdef + AND NOT EXISTS ( + SELECT 1 FROM encrypted_domain_blockers b + WHERE b.oid = op_impl.impl_oid + ) -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer -); + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ Transitive inlinability: an operator implementation function │ + -- │ that's itself inlinable can still fail to inline if its body │ + -- │ calls a non-inlinable function. Walk one level via pg_depend. │ + -- │ │ + -- │ Postgres records function-to-function dependencies in │ + -- │ pg_depend with deptype 'n' (normal) when one function references│ + -- │ another in its body — but only at CREATE time and only for │ + -- │ direct calls. This is good enough for v1; deeper transitive │ + -- │ analysis is a follow-up. │ + -- └─────────────────────────────────────────────────────────────────┘ -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore -); + UNION ALL -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text -); + SELECT + 'error', + 'inlinability_transitive', + format('operator %s(%s, %s) -> %s', oi.opname, oi.lhs, oi.rhs, + oi.impl_signature), + format( + '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.', + called.proname, + called_lang.lanname, + CASE called.provolatile + WHEN 'i' THEN 'IMMUTABLE' + WHEN 's' THEN 'STABLE' + WHEN 'v' THEN 'VOLATILE' + END, + CASE WHEN called.proconfig IS NOT NULL + THEN ', has SET clause' + ELSE '' END) + FROM op_impl oi + -- Only worth the transitive check if the outer function is otherwise + -- inlinable — otherwise the direct lints above already report it. + JOIN pg_proc outer_p ON outer_p.oid = oi.impl_signature::regprocedure + JOIN pg_depend d + ON d.classid = 'pg_proc'::regclass + AND d.objid = outer_p.oid + AND d.refclassid = 'pg_proc'::regclass + AND d.deptype = 'n' + JOIN pg_proc called ON called.oid = d.refobjid + JOIN pg_language called_lang ON called_lang.oid = called.prolang + WHERE oi.lang = 'sql' + AND oi.volatility IN ('i', 's') + AND oi.config IS NULL + AND NOT oi.secdef + AND called.oid <> outer_p.oid + AND ( + called_lang.lanname <> 'sql' + OR called.provolatile = 'v' + OR called.proconfig IS NOT NULL + OR called.prosecdef + ) -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer -); + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ Encrypted-domain footguns: blockers exist to RAISE, so they │ + -- │ have inverted inlinability requirements vs operator impls. │ + -- │ A LANGUAGE sql blocker can be elided by the planner; a STRICT │ + -- │ blocker returns NULL on NULL args. Both silently re-enable │ + -- │ operators the storage variant is supposed to block. │ + -- └─────────────────────────────────────────────────────────────────┘ -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore -); + UNION ALL -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text -); + SELECT + 'error', + 'blocker_language', + format('function %s', signature), + format( + '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.', + lang) + FROM encrypted_domain_blockers + WHERE lang <> 'plpgsql' -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[] -); + UNION ALL -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[] -); + SELECT + 'error', + 'blocker_strict', + format('function %s', signature), + 'Encrypted-domain blocker is `STRICT`. PostgreSQL skips the body and returns NULL on a NULL argument, silently bypassing the RAISE. Remove `STRICT`.' + FROM encrypted_domain_blockers + WHERE isstrict -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonpath -); + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ Domain identity: an encrypted-domain must be defined directly │ + -- │ over jsonb. Operators resolve against the ultimate base type, │ + -- │ so domain-over-domain inherits jsonb's operator surface and not │ + -- │ the base domain's blockers. │ + -- └─────────────────────────────────────────────────────────────────┘ -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonpath -); + UNION ALL -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[] -); + SELECT + 'error', + 'domain_over_domain', + format('domain %I.%I', dn.nspname, dt.typname), + format( + '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.', + dn.nspname, dt.typname, bn.nspname, bt.typname) + FROM pg_catalog.pg_type dt + JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace + JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype + JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace + WHERE dt.typtype = 'd' + AND dn.nspname = ANY(eql_v3_internal.owned_schemas()) + AND bt.typtype = 'd' + AND bt.oid IN (SELECT typid FROM encrypted_domain_types) -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[] -); + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ Domain opclass: an operator class declared FOR TYPE on an │ + -- │ encrypted-domain bypasses operator resolution at index time. │ + -- │ Use a functional index on the extractor instead. │ + -- └─────────────────────────────────────────────────────────────────┘ -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text -); + UNION ALL -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer -); + SELECT + 'error', + 'domain_opclass', + format('opclass %I.%I FOR TYPE %s.%s', cn.nspname, oc.opcname, tn.nspname, t.typname), + format( + '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.', + cn.nspname, oc.opcname, tn.nspname, t.typname, tn.nspname, tn.nspname) + FROM pg_catalog.pg_opclass oc + JOIN pg_catalog.pg_type t ON t.oid = oc.opcintype + JOIN pg_catalog.pg_namespace tn ON tn.oid = t.typnamespace + JOIN pg_catalog.pg_namespace cn ON cn.oid = oc.opcnamespace + WHERE t.oid IN (SELECT typid FROM encrypted_domain_types) -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[] -); + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ Schema placement: the public `eql_v3` schema must hold only the │ + -- │ jsonb-backed encrypted-domain types. A naked composite/enum type │ + -- │ there is an internal index-term type in the wrong schema — it │ + -- │ clutters the Supabase type picker the split exists to keep clean. │ + -- └─────────────────────────────────────────────────────────────────┘ -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[] -); + UNION ALL -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore -); + SELECT + 'error', + 'schema_placement', + format('type %I.%I', n.nspname, t.typname), + format( + '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.nspname, t.typname, + CASE t.typtype WHEN 'c' THEN 'composite type' WHEN 'e' THEN 'enum type' ELSE 'type' END) + FROM pg_catalog.pg_type t + JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace + WHERE n.nspname = 'eql_v3' + AND t.typtype IN ('c', 'e') -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb -); + ORDER BY 1, 2, 3; +$$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore -); +COMMENT ON FUNCTION eql_v3.lints() IS + 'EQL lint: returns one row per non-inlinable operator implementation. ' + 'Run `SELECT * FROM eql_v3.lints() WHERE severity = ''error''` for a ' + 'CI-gateable check that all operator implementations on eql_v3 types are ' + 'eligible for planner inlining.'; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/real_ord_ope_operators.sql ---! @brief Operators for public.eql_v3_real_ord_ope. +--! @file encrypted_domain/bigint/bigint_operators.sql +--! @brief Operators for public.eql_v3_bigint. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope + LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb + LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope + LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb + LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_bigint, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer + LEFTARG = public.eql_v3_bigint, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_bigint, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer + LEFTARG = public.eql_v3_bigint, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_bigint, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_bigint, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_bigint, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_bigint, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_bigint, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_bigint, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer + LEFTARG = public.eql_v3_bigint, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_bigint, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_bigint, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope + LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb + LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/real_ord_operators.sql ---! @brief Operators for public.eql_v3_real_ord. +--! @file encrypted_domain/bigint/bigint_eq_functions.sql +--! @brief Functions for public.eql_v3_bigint_eq. -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Index extractor for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_bigint_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_bigint_eq) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_bigint_eq. +--! @param a jsonb +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) = eql_v3.eq_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_bigint_eq) $$; + +--! @brief Operator wrapper for public.eql_v3_bigint_eq. +--! @param a jsonb +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a jsonb +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a jsonb +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a jsonb +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a jsonb +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a jsonb +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a jsonb +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param selector text +--! @return public.eql_v3_bigint_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_eq, selector text) +RETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param selector integer +--! @return public.eql_v3_bigint_eq +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_eq, selector integer) +RETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a jsonb +--! @param selector public.eql_v3_bigint_eq +--! @return public.eql_v3_bigint_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_eq) +RETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a jsonb +--! @param selector public.eql_v3_bigint_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a jsonb +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b public.eql_v3_bigint_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord -); +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @param a jsonb +--! @param b public.eql_v3_bigint_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = text -); +--! @file encrypted_domain/bigint/query_bigint_ord_ore_functions.sql +--! @brief Functions for eql_v3.query_bigint_ord_ore. -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer -); +--! @brief Index extractor for eql_v3.query_bigint_ord_ore. +--! @param a eql_v3.query_bigint_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_bigint_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord -); +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b eql_v3.query_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = text -); +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. +--! @param a eql_v3.query_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer -); +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b eql_v3.query_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord -); +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. +--! @param a eql_v3.query_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = text -); +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b eql_v3.query_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. +--! @param a eql_v3.query_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b eql_v3.query_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonpath -); +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. +--! @param a eql_v3.query_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonpath -); +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b eql_v3.query_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. +--! @param a eql_v3.query_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. +--! @param a public.eql_v3_bigint_ord_ore +--! @param b eql_v3.query_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = text -); +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. +--! @param a eql_v3.query_bigint_ord_ore +--! @param b public.eql_v3_bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer -); +--! @file encrypted_domain/bigint/query_bigint_eq_functions.sql +--! @brief Functions for eql_v3.query_bigint_eq. -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[] -); +--! @brief Index extractor for eql_v3.query_bigint_eq. +--! @param a eql_v3.query_bigint_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_bigint_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b eql_v3.query_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b eql_v3.query_bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord -); +--! @brief Operator wrapper for eql_v3.query_bigint_eq. +--! @param a eql_v3.query_bigint_eq +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_eq, b public.eql_v3_bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb -); +--! @brief Operator wrapper for eql_v3.query_bigint_eq. +--! @param a public.eql_v3_bigint_eq +--! @param b eql_v3.query_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b eql_v3.query_bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord -); +--! @brief Operator wrapper for eql_v3.query_bigint_eq. +--! @param a eql_v3.query_bigint_eq +--! @param b public.eql_v3_bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_eq, b public.eql_v3_bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/real_functions.sql ---! @brief Functions for public.eql_v3_real. +--! @file encrypted_domain/bigint/bigint_ord_ope_functions.sql +--! @brief Functions for public.eql_v3_bigint_ord_ope. ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real +--! @brief Index extractor for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_bigint_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b public.eql_v3_real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) = eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b public.eql_v3_real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) <> eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b public.eql_v3_real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) < eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b public.eql_v3_real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) <= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b public.eql_v3_real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) > eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b public.eql_v3_real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) >= eql_v3.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b public.eql_v3_real) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b jsonb) +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real) +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b public.eql_v3_real) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b jsonb) +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real) +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param selector text ---! @return public.eql_v3_real -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real, selector text) -RETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$ +--! @return public.eql_v3_bigint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ope, selector text) +RETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param selector integer ---! @return public.eql_v3_real -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real, selector integer) -RETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$ +--! @return public.eql_v3_bigint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ope, selector integer) +RETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. --! @param a jsonb ---! @param selector public.eql_v3_real ---! @return public.eql_v3_real -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real) -RETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$ +--! @param selector public.eql_v3_bigint_ord_ope +--! @return public.eql_v3_bigint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_ord_ope) +RETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param selector text --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real, selector text) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param selector integer --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real, selector integer) +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. --! @param a jsonb ---! @param selector public.eql_v3_real +--! @param selector public.eql_v3_bigint_ord_ope --! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real) +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b text --! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real, b text) +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real, b text[]) +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b text[] --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real, b text[]) +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real, b jsonpath) +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a jsonb +--! @param b public.eql_v3_bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_bigint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b jsonpath --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real, b jsonpath) +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real, b text[]) +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b text[] --! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real, b text[]) +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b text --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real, b text) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b integer --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real, b integer) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real, b text[]) +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b text[] --! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real, b text[]) +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real, b public.eql_v3_real) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope --! @param b jsonb --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real, b jsonb) +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real +--! @param b public.eql_v3_bigint_ord_ope --! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real) +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/query_real_ord_ore_functions.sql ---! @brief Functions for eql_v3.query_real_ord_ore. - ---! @brief Index extractor for eql_v3.query_real_ord_ore. ---! @param a eql_v3.query_real_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_real_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.query_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b eql_v3.query_real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_real_ord_ore. ---! @param a eql_v3.query_real_ord_ore ---! @param b public.eql_v3_real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; - ---! @brief Operator wrapper for eql_v3.query_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b eql_v3.query_real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +--! @file encrypted_domain/bigint/bigint_ord_ore_aggregates.sql +--! @brief Aggregates for public.eql_v3_bigint_ord_ore. ---! @brief Operator wrapper for eql_v3.query_real_ord_ore. ---! @param a eql_v3.query_real_ord_ore ---! @param b public.eql_v3_real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +--! @brief State function for min on public.eql_v3_bigint_ord_ore. +--! @param state public.eql_v3_bigint_ord_ore +--! @param value public.eql_v3_bigint_ord_ore +--! @return public.eql_v3_bigint_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord_ore, value public.eql_v3_bigint_ord_ore) +RETURNS public.eql_v3_bigint_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Operator wrapper for eql_v3.query_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b eql_v3.query_real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +--! @brief min aggregate for public.eql_v3_bigint_ord_ore. +--! @param input public.eql_v3_bigint_ord_ore +--! @return public.eql_v3_bigint_ord_ore +CREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_bigint_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); ---! @brief Operator wrapper for eql_v3.query_real_ord_ore. ---! @param a eql_v3.query_real_ord_ore ---! @param b public.eql_v3_real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +--! @brief State function for max on public.eql_v3_bigint_ord_ore. +--! @param state public.eql_v3_bigint_ord_ore +--! @param value public.eql_v3_bigint_ord_ore +--! @return public.eql_v3_bigint_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord_ore, value public.eql_v3_bigint_ord_ore) +RETURNS public.eql_v3_bigint_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Operator wrapper for eql_v3.query_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b eql_v3.query_real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +--! @brief max aggregate for public.eql_v3_bigint_ord_ore. +--! @param input public.eql_v3_bigint_ord_ore +--! @return public.eql_v3_bigint_ord_ore +CREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_bigint_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Operator wrapper for eql_v3.query_real_ord_ore. ---! @param a eql_v3.query_real_ord_ore ---! @param b public.eql_v3_real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +--! @file encrypted_domain/bigint/bigint_ord_aggregates.sql +--! @brief Aggregates for public.eql_v3_bigint_ord. ---! @brief Operator wrapper for eql_v3.query_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b eql_v3.query_real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +--! @brief State function for min on public.eql_v3_bigint_ord. +--! @param state public.eql_v3_bigint_ord +--! @param value public.eql_v3_bigint_ord +--! @return public.eql_v3_bigint_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord, value public.eql_v3_bigint_ord) +RETURNS public.eql_v3_bigint_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Operator wrapper for eql_v3.query_real_ord_ore. ---! @param a eql_v3.query_real_ord_ore ---! @param b public.eql_v3_real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +--! @brief min aggregate for public.eql_v3_bigint_ord. +--! @param input public.eql_v3_bigint_ord +--! @return public.eql_v3_bigint_ord +CREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_bigint_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); ---! @brief Operator wrapper for eql_v3.query_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b eql_v3.query_real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +--! @brief State function for max on public.eql_v3_bigint_ord. +--! @param state public.eql_v3_bigint_ord +--! @param value public.eql_v3_bigint_ord +--! @return public.eql_v3_bigint_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord, value public.eql_v3_bigint_ord) +RETURNS public.eql_v3_bigint_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Operator wrapper for eql_v3.query_real_ord_ore. ---! @param a eql_v3.query_real_ord_ore ---! @param b public.eql_v3_real_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +--! @brief max aggregate for public.eql_v3_bigint_ord. +--! @param input public.eql_v3_bigint_ord +--! @return public.eql_v3_bigint_ord +CREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_bigint_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/query_real_ord_functions.sql ---! @brief Functions for eql_v3.query_real_ord. +--! @file encrypted_domain/bigint/query_bigint_ord_ope_functions.sql +--! @brief Functions for eql_v3.query_bigint_ord_ope. ---! @brief Index extractor for eql_v3.query_real_ord. ---! @param a eql_v3.query_real_ord +--! @brief Index extractor for eql_v3.query_bigint_ord_ope. +--! @param a eql_v3.query_bigint_ord_ope --! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_real_ord) +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_bigint_ord_ope) RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b eql_v3.query_real_ord +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b eql_v3.query_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b eql_v3.query_real_ord) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord. ---! @param a eql_v3.query_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. +--! @param a eql_v3.query_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b eql_v3.query_real_ord +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b eql_v3.query_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b eql_v3.query_real_ord) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord. ---! @param a eql_v3.query_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. +--! @param a eql_v3.query_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b eql_v3.query_real_ord +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b eql_v3.query_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b eql_v3.query_real_ord) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord. ---! @param a eql_v3.query_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. +--! @param a eql_v3.query_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b eql_v3.query_real_ord +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b eql_v3.query_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b eql_v3.query_real_ord) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord. ---! @param a eql_v3.query_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. +--! @param a eql_v3.query_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b eql_v3.query_real_ord +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b eql_v3.query_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b eql_v3.query_real_ord) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord. ---! @param a eql_v3.query_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. +--! @param a eql_v3.query_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b eql_v3.query_real_ord +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. +--! @param a public.eql_v3_bigint_ord_ope +--! @param b eql_v3.query_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b eql_v3.query_real_ord) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord. ---! @param a eql_v3.query_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. +--! @param a eql_v3.query_bigint_ord_ope +--! @param b public.eql_v3_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/query_real_ord_ope_functions.sql ---! @brief Functions for eql_v3.query_real_ord_ope. - ---! @brief Index extractor for eql_v3.query_real_ord_ope. ---! @param a eql_v3.query_real_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_real_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +--! @file encrypted_domain/bigint/query_bigint_ord_operators.sql +--! @brief Operators for eql_v3.query_bigint_ord. ---! @brief Operator wrapper for eql_v3.query_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b eql_v3.query_real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_real_ord_ope. ---! @param a eql_v3.query_real_ord_ope ---! @param b public.eql_v3_real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b eql_v3.query_real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_real_ord_ope. ---! @param a eql_v3.query_real_ord_ope ---! @param b public.eql_v3_real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b eql_v3.query_real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for eql_v3.query_real_ord_ope. ---! @param a eql_v3.query_real_ord_ope ---! @param b public.eql_v3_real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for eql_v3.query_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b eql_v3.query_real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for eql_v3.query_real_ord_ope. ---! @param a eql_v3.query_real_ord_ope ---! @param b public.eql_v3_real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for eql_v3.query_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b eql_v3.query_real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for eql_v3.query_real_ord_ope. ---! @param a eql_v3.query_real_ord_ope ---! @param b public.eql_v3_real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for eql_v3.query_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b eql_v3.query_real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for eql_v3.query_real_ord_ope. ---! @param a eql_v3.query_real_ord_ope ---! @param b public.eql_v3_real_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/query_real_eq_functions.sql ---! @brief Functions for eql_v3.query_real_eq. +--! @file encrypted_domain/bigint/bigint_ord_ope_operators.sql +--! @brief Operators for public.eql_v3_bigint_ord_ope. ---! @brief Index extractor for eql_v3.query_real_eq. ---! @param a eql_v3.query_real_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_real_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b eql_v3.query_real_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b eql_v3.query_real_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_real_eq. ---! @param a eql_v3.query_real_eq ---! @param b public.eql_v3_real_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_real_eq, b public.eql_v3_real_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b eql_v3.query_real_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b eql_v3.query_real_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_real_eq. ---! @param a eql_v3.query_real_eq ---! @param b public.eql_v3_real_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_real_eq, b public.eql_v3_real_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @file v3/sem/ore_block_256/operator_class.sql ---! @brief B-tree operator family + default class on eql_v3_internal.ore_block_256. ---! ---! Gives the composite type its DEFAULT btree opclass so the recommended ---! functional index `CREATE INDEX ON t (eql_v3.ord_term_ore(col))` engages without ---! an explicit opclass annotation (design D4). ---! ---! @note Creating an operator family/class requires superuser: Postgres forbids ---! CREATE OPERATOR FAMILY / CLASS to non-superusers to protect index ---! integrity. Managed platforms (Supabase, and most hosted Postgres) run ---! the installer as a non-superuser role, so the DO block below ATTEMPTS ---! the creation and skips it on insufficient_privilege (SQLSTATE 42501), ---! letting the single installer run everywhere. When the class is absent, ---! ORE ordered scans over eql_v3_internal.ore_block_256 are unavailable, ---! but the order-preserving (OPE) ordering domains — whose extractor ---! return types carry a native btree opclass — still index without it. On ---! superuser installs (self-managed Postgres, the SQLx test matrix) the ---! class is created normally. Any non-privilege error still propagates. ---! @see eql_v3_internal.compare_ore_block_256_terms +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); -DO $do$ -BEGIN - EXECUTE 'CREATE OPERATOR FAMILY eql_v3_internal.ore_block_256_operator_family USING btree'; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); - EXECUTE $ddl$ - CREATE OPERATOR CLASS eql_v3_internal.ore_block_256_operator_class - DEFAULT FOR TYPE eql_v3_internal.ore_block_256 - USING btree FAMILY eql_v3_internal.ore_block_256_operator_family AS - OPERATOR 1 public.<, - OPERATOR 2 public.<=, - OPERATOR 3 public.=, - OPERATOR 4 public.>=, - OPERATOR 5 public.>, - FUNCTION 1 eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) - $ddl$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); - RAISE NOTICE 'EQL: created btree operator class eql_v3_internal.ore_block_256_operator_class'; -EXCEPTION - WHEN insufficient_privilege THEN - 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'; -END; -$do$; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @file encrypted_domain/numeric/query_numeric_ord_ore_functions.sql ---! @brief Functions for eql_v3.query_numeric_ord_ore. +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Index extractor for eql_v3.query_numeric_ord_ore. ---! @param a eql_v3.query_numeric_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_numeric_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b eql_v3.query_numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. ---! @param a eql_v3.query_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b eql_v3.query_numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. ---! @param a eql_v3.query_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b eql_v3.query_numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. ---! @param a eql_v3.query_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b eql_v3.query_numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. ---! @param a eql_v3.query_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b eql_v3.query_numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. ---! @param a eql_v3.query_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b eql_v3.query_numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. ---! @param a eql_v3.query_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer +); ---! @file encrypted_domain/numeric/query_numeric_ord_functions.sql ---! @brief Functions for eql_v3.query_numeric_ord. +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope +); ---! @brief Index extractor for eql_v3.query_numeric_ord. ---! @param a eql_v3.query_numeric_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_numeric_ord) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b eql_v3.query_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord. ---! @param a eql_v3.query_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b eql_v3.query_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonpath +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord. ---! @param a eql_v3.query_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b eql_v3.query_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord. ---! @param a eql_v3.query_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b eql_v3.query_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonpath +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord. ---! @param a eql_v3.query_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b eql_v3.query_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord. ---! @param a eql_v3.query_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b eql_v3.query_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord. ---! @param a eql_v3.query_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[] +); ---! @file encrypted_domain/numeric/query_numeric_ord_ope_functions.sql ---! @brief Functions for eql_v3.query_numeric_ord_ope. +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[] +); ---! @brief Index extractor for eql_v3.query_numeric_ord_ope. ---! @param a eql_v3.query_numeric_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_numeric_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b eql_v3.query_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. ---! @param a eql_v3.query_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b eql_v3.query_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +--! @file encrypted_domain/bigint/query_bigint_eq_operators.sql +--! @brief Operators for eql_v3.query_bigint_eq. ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. ---! @param a eql_v3.query_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = eql_v3.query_bigint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b eql_v3.query_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. ---! @param a eql_v3.query_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = eql_v3.query_bigint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b eql_v3.query_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. ---! @param a eql_v3.query_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +--! @file encrypted_domain/bigint/query_bigint_ord_ore_operators.sql +--! @brief Operators for eql_v3.query_bigint_ord_ore. ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b eql_v3.query_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. ---! @param a eql_v3.query_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b eql_v3.query_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. ---! @param a eql_v3.query_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @file encrypted_domain/numeric/query_numeric_eq_functions.sql ---! @brief Functions for eql_v3.query_numeric_eq. +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Index extractor for eql_v3.query_numeric_eq. ---! @param a eql_v3.query_numeric_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_numeric_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for eql_v3.query_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b eql_v3.query_numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b eql_v3.query_numeric_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for eql_v3.query_numeric_eq. ---! @param a eql_v3.query_numeric_eq ---! @param b public.eql_v3_numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_eq, b public.eql_v3_numeric_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for eql_v3.query_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b eql_v3.query_numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b eql_v3.query_numeric_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for eql_v3.query_numeric_eq. ---! @param a eql_v3.query_numeric_eq ---! @param b public.eql_v3_numeric_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_eq, b public.eql_v3_numeric_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/numeric/numeric_ord_ore_operators.sql ---! @brief Operators for public.eql_v3_numeric_ord_ore. +--! @file encrypted_domain/bigint/bigint_eq_operators.sql +--! @brief Operators for public.eql_v3_bigint_eq. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/numeric/numeric_ord_ope_operators.sql ---! @brief Operators for public.eql_v3_numeric_ord_ope. +--! @file encrypted_domain/bigint/bigint_ord_ope_aggregates.sql +--! @brief Aggregates for public.eql_v3_bigint_ord_ope. + +--! @brief State function for min on public.eql_v3_bigint_ord_ope. +--! @param state public.eql_v3_bigint_ord_ope +--! @param value public.eql_v3_bigint_ord_ope +--! @return public.eql_v3_bigint_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord_ope, value public.eql_v3_bigint_ord_ope) +RETURNS public.eql_v3_bigint_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.eql_v3_bigint_ord_ope. +--! @param input public.eql_v3_bigint_ord_ope +--! @return public.eql_v3_bigint_ord_ope +CREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_bigint_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.eql_v3_bigint_ord_ope. +--! @param state public.eql_v3_bigint_ord_ope +--! @param value public.eql_v3_bigint_ord_ope +--! @return public.eql_v3_bigint_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord_ope, value public.eql_v3_bigint_ord_ope) +RETURNS public.eql_v3_bigint_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.eql_v3_bigint_ord_ope. +--! @param input public.eql_v3_bigint_ord_ope +--! @return public.eql_v3_bigint_ord_ope +CREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_bigint_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/query_bigint_ord_ope_operators.sql +--! @brief Operators for eql_v3.query_bigint_ord_ope. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb, + LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/query_real_ord_ore_operators.sql +--! @brief Operators for eql_v3.query_real_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope, + LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb, + LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ore_operators.sql +--! @brief Operators for public.eql_v3_real_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/numeric/numeric_ord_operators.sql ---! @brief Operators for public.eql_v3_numeric_ord. +--! @file encrypted_domain/real/real_ord_operators.sql +--! @brief Operators for public.eql_v3_real_ord. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord + LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord + LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text + LEFTARG = public.eql_v3_real_ord, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text + LEFTARG = public.eql_v3_real_ord, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text + LEFTARG = public.eql_v3_real_ord, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_functions.sql ---! @brief Functions for public.eql_v3_numeric. - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b public.eql_v3_numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b public.eql_v3_numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b public.eql_v3_numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b public.eql_v3_numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b public.eql_v3_numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b public.eql_v3_numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b public.eql_v3_numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b public.eql_v3_numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param selector text ---! @return public.eql_v3_numeric -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric, selector text) -RETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param selector integer ---! @return public.eql_v3_numeric -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric, selector integer) -RETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param selector public.eql_v3_numeric ---! @return public.eql_v3_numeric -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric) -RETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param selector public.eql_v3_numeric ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric, b public.eql_v3_numeric) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/integer/query_integer_ord_ore_functions.sql ---! @brief Functions for eql_v3.query_integer_ord_ore. - ---! @brief Index extractor for eql_v3.query_integer_ord_ore. ---! @param a eql_v3.query_integer_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_integer_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonpath +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b eql_v3.query_integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ore. ---! @param a eql_v3.query_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b eql_v3.query_integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ore. ---! @param a eql_v3.query_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonpath +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b eql_v3.query_integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ore. ---! @param a eql_v3.query_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b eql_v3.query_integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_real_ord, RIGHTARG = text +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ore. ---! @param a eql_v3.query_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b eql_v3.query_integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ore. ---! @param a eql_v3.query_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b eql_v3.query_integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ore. ---! @param a eql_v3.query_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord +); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/integer/query_integer_ord_functions.sql ---! @brief Functions for eql_v3.query_integer_ord. +--! @file encrypted_domain/real/query_real_ord_functions.sql +--! @brief Functions for eql_v3.query_real_ord. ---! @brief Index extractor for eql_v3.query_integer_ord. ---! @param a eql_v3.query_integer_ord +--! @brief Index extractor for eql_v3.query_real_ord. +--! @param a eql_v3.query_real_ord --! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_integer_ord) +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_real_ord) RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b eql_v3.query_integer_ord +--! @brief Operator wrapper for eql_v3.query_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b eql_v3.query_real_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b eql_v3.query_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord. ---! @param a eql_v3.query_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for eql_v3.query_real_ord. +--! @param a eql_v3.query_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b eql_v3.query_integer_ord +--! @brief Operator wrapper for eql_v3.query_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b eql_v3.query_real_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b eql_v3.query_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord. ---! @param a eql_v3.query_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for eql_v3.query_real_ord. +--! @param a eql_v3.query_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b eql_v3.query_integer_ord +--! @brief Operator wrapper for eql_v3.query_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b eql_v3.query_real_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b eql_v3.query_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord. ---! @param a eql_v3.query_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for eql_v3.query_real_ord. +--! @param a eql_v3.query_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b eql_v3.query_integer_ord +--! @brief Operator wrapper for eql_v3.query_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b eql_v3.query_real_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b eql_v3.query_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord. ---! @param a eql_v3.query_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for eql_v3.query_real_ord. +--! @param a eql_v3.query_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b eql_v3.query_integer_ord +--! @brief Operator wrapper for eql_v3.query_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b eql_v3.query_real_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b eql_v3.query_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord. ---! @param a eql_v3.query_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for eql_v3.query_real_ord. +--! @param a eql_v3.query_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b eql_v3.query_integer_ord +--! @brief Operator wrapper for eql_v3.query_real_ord. +--! @param a public.eql_v3_real_ord +--! @param b eql_v3.query_real_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b eql_v3.query_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord. ---! @param a eql_v3.query_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for eql_v3.query_real_ord. +--! @param a eql_v3.query_real_ord +--! @param b public.eql_v3_real_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord, b public.eql_v3_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/integer/query_integer_ord_ope_functions.sql ---! @brief Functions for eql_v3.query_integer_ord_ope. +--! @file encrypted_domain/real/real_ord_ore_aggregates.sql +--! @brief Aggregates for public.eql_v3_real_ord_ore. ---! @brief Index extractor for eql_v3.query_integer_ord_ope. ---! @param a eql_v3.query_integer_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_integer_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +--! @brief State function for min on public.eql_v3_real_ord_ore. +--! @param state public.eql_v3_real_ord_ore +--! @param value public.eql_v3_real_ord_ore +--! @return public.eql_v3_real_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord_ore, value public.eql_v3_real_ord_ore) +RETURNS public.eql_v3_real_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Operator wrapper for eql_v3.query_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b eql_v3.query_integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +--! @brief min aggregate for public.eql_v3_real_ord_ore. +--! @param input public.eql_v3_real_ord_ore +--! @return public.eql_v3_real_ord_ore +CREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_real_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ope. ---! @param a eql_v3.query_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +--! @brief State function for max on public.eql_v3_real_ord_ore. +--! @param state public.eql_v3_real_ord_ore +--! @param value public.eql_v3_real_ord_ore +--! @return public.eql_v3_real_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord_ore, value public.eql_v3_real_ord_ore) +RETURNS public.eql_v3_real_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Operator wrapper for eql_v3.query_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b eql_v3.query_integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +--! @brief max aggregate for public.eql_v3_real_ord_ore. +--! @param input public.eql_v3_real_ord_ore +--! @return public.eql_v3_real_ord_ore +CREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_real_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Operator wrapper for eql_v3.query_integer_ord_ope. ---! @param a eql_v3.query_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +--! @file encrypted_domain/real/real_ord_ope_operators.sql +--! @brief Operators for public.eql_v3_real_ord_ope. ---! @brief Operator wrapper for eql_v3.query_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b eql_v3.query_integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ope. ---! @param a eql_v3.query_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b eql_v3.query_integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ope. ---! @param a eql_v3.query_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonpath +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b eql_v3.query_integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ope. ---! @param a eql_v3.query_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b eql_v3.query_integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope +); ---! @brief Operator wrapper for eql_v3.query_integer_ord_ope. ---! @param a eql_v3.query_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonpath +); ---! @file encrypted_domain/integer/query_integer_eq_functions.sql ---! @brief Functions for eql_v3.query_integer_eq. +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[] +); ---! @brief Index extractor for eql_v3.query_integer_eq. ---! @param a eql_v3.query_integer_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_integer_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b eql_v3.query_integer_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b eql_v3.query_integer_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text +); ---! @brief Operator wrapper for eql_v3.query_integer_eq. ---! @param a eql_v3.query_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_eq, b public.eql_v3_integer_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer +); ---! @brief Operator wrapper for eql_v3.query_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b eql_v3.query_integer_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b eql_v3.query_integer_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_integer_eq. ---! @param a eql_v3.query_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_eq, b public.eql_v3_integer_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[] +); ---! @file encrypted_domain/integer/integer_ord_ore_operators.sql ---! @brief Operators for public.eql_v3_integer_ord_ore. +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope +); -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope ); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/query_real_eq_operators.sql +--! @brief Operators for eql_v3.query_real_eq. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = eql_v3.query_real_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore, + LEFTARG = eql_v3.query_real_eq, RIGHTARG = public.eql_v3_real_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = eql_v3.query_real_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb, + LEFTARG = eql_v3.query_real_eq, RIGHTARG = public.eql_v3_real_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/query_real_ord_ope_operators.sql +--! @brief Operators for eql_v3.query_real_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore, + LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore, + LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore, + LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb, + LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @file encrypted_domain/real/real_functions.sql +--! @brief Functions for public.eql_v3_real. -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b public.eql_v3_real +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a jsonb +--! @param b public.eql_v3_real +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b public.eql_v3_real +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a jsonb +--! @param b public.eql_v3_real +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b public.eql_v3_real +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a jsonb +--! @param b public.eql_v3_real +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b public.eql_v3_real +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a jsonb +--! @param b public.eql_v3_real +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b public.eql_v3_real +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a jsonb +--! @param b public.eql_v3_real +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b public.eql_v3_real +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a jsonb +--! @param b public.eql_v3_real +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b public.eql_v3_real +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a jsonb +--! @param b public.eql_v3_real +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b public.eql_v3_real +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a jsonb +--! @param b public.eql_v3_real +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param selector text +--! @return public.eql_v3_real +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real, selector text) +RETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param selector integer +--! @return public.eql_v3_real +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real, selector integer) +RETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a jsonb +--! @param selector public.eql_v3_real +--! @return public.eql_v3_real +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real) +RETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a jsonb +--! @param selector public.eql_v3_real +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b public.eql_v3_real +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a jsonb +--! @param b public.eql_v3_real +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b public.eql_v3_real +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real, b public.eql_v3_real) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a public.eql_v3_real +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! @param a jsonb +--! @param b public.eql_v3_real +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[] -); +--! @file encrypted_domain/real/real_ord_aggregates.sql +--! @brief Aggregates for public.eql_v3_real_ord. -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[] -); +--! @brief State function for min on public.eql_v3_real_ord. +--! @param state public.eql_v3_real_ord +--! @param value public.eql_v3_real_ord +--! @return public.eql_v3_real_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord, value public.eql_v3_real_ord) +RETURNS public.eql_v3_real_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore +--! @brief min aggregate for public.eql_v3_real_ord. +--! @param input public.eql_v3_real_ord +--! @return public.eql_v3_real_ord +CREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_real_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe ); -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb -); +--! @brief State function for max on public.eql_v3_real_ord. +--! @param state public.eql_v3_real_ord +--! @param value public.eql_v3_real_ord +--! @return public.eql_v3_real_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord, value public.eql_v3_real_ord) +RETURNS public.eql_v3_real_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore +--! @brief max aggregate for public.eql_v3_real_ord. +--! @param input public.eql_v3_real_ord +--! @return public.eql_v3_real_ord +CREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_real_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/integer/integer_ord_ope_operators.sql ---! @brief Operators for public.eql_v3_integer_ord_ope. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @file encrypted_domain/real/query_real_ord_operators.sql +--! @brief Operators for eql_v3.query_real_ord. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope, + LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope, + LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope, + LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope, + LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope, + LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope, + LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope -); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/integer/integer_ord_operators.sql ---! @brief Operators for public.eql_v3_integer_ord. +--! @file encrypted_domain/real/real_operators.sql +--! @brief Operators for public.eql_v3_real. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.eql_v3_real, RIGHTARG = jsonb ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.eql_v3_real, RIGHTARG = jsonb ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_real, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_real, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_real, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_real, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord + LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord + LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text + LEFTARG = public.eql_v3_real, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_real, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text + LEFTARG = public.eql_v3_real, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_real, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text + LEFTARG = public.eql_v3_real, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_real, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_real, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_real, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_real, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_real, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_real, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_real, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text + LEFTARG = public.eql_v3_real, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_real, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_real, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_real, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord + LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_real, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/integer/integer_functions.sql ---! @brief Functions for public.eql_v3_integer. - ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b public.eql_v3_integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/real/real_ord_ope_aggregates.sql +--! @brief Aggregates for public.eql_v3_real_ord_ope. ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b public.eql_v3_integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +--! @brief State function for min on public.eql_v3_real_ord_ope. +--! @param state public.eql_v3_real_ord_ope +--! @param value public.eql_v3_real_ord_ope +--! @return public.eql_v3_real_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord_ope, value public.eql_v3_real_ord_ope) +RETURNS public.eql_v3_real_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +--! @brief min aggregate for public.eql_v3_real_ord_ope. +--! @param input public.eql_v3_real_ord_ope +--! @return public.eql_v3_real_ord_ope +CREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_real_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +--! @brief State function for max on public.eql_v3_real_ord_ope. +--! @param state public.eql_v3_real_ord_ope +--! @param value public.eql_v3_real_ord_ope +--! @return public.eql_v3_real_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord_ope, value public.eql_v3_real_ord_ope) +RETURNS public.eql_v3_real_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b public.eql_v3_integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +--! @brief max aggregate for public.eql_v3_real_ord_ope. +--! @param input public.eql_v3_real_ord_ope +--! @return public.eql_v3_real_ord_ope +CREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_real_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/real/real_eq_operators.sql +--! @brief Operators for public.eql_v3_real_eq. ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b public.eql_v3_integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b public.eql_v3_integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b public.eql_v3_integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b public.eql_v3_integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b public.eql_v3_integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param selector text ---! @return public.eql_v3_integer -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer, selector text) -RETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param selector integer ---! @return public.eql_v3_integer -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer, selector integer) -RETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param selector public.eql_v3_integer ---! @return public.eql_v3_integer -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer) -RETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param selector public.eql_v3_integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer, b public.eql_v3_integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonpath +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq +); ---! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb +); ---! @file encrypted_domain/double/query_double_ord_ore_functions.sql ---! @brief Functions for eql_v3.query_double_ord_ore. +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq +); ---! @brief Index extractor for eql_v3.query_double_ord_ore. ---! @param a eql_v3.query_double_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_double_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonpath +); ---! @brief Operator wrapper for eql_v3.query_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b eql_v3.query_double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_double_ord_ore. ---! @param a eql_v3.query_double_ord_ore ---! @param b public.eql_v3_double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b eql_v3.query_double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = text +); ---! @brief Operator wrapper for eql_v3.query_double_ord_ore. ---! @param a eql_v3.query_double_ord_ore ---! @param b public.eql_v3_double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer +); ---! @brief Operator wrapper for eql_v3.query_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b eql_v3.query_double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_double_ord_ore. ---! @param a eql_v3.query_double_ord_ore ---! @param b public.eql_v3_double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b eql_v3.query_double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq +); ---! @brief Operator wrapper for eql_v3.query_double_ord_ore. ---! @param a eql_v3.query_double_ord_ore ---! @param b public.eql_v3_double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb +); ---! @brief Operator wrapper for eql_v3.query_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b eql_v3.query_double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Operator wrapper for eql_v3.query_double_ord_ore. ---! @param a eql_v3.query_double_ord_ore ---! @param b public.eql_v3_double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +--! @file encrypted_domain/smallint/smallint_ord_ore_aggregates.sql +--! @brief Aggregates for public.eql_v3_smallint_ord_ore. ---! @brief Operator wrapper for eql_v3.query_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b eql_v3.query_double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +--! @brief State function for min on public.eql_v3_smallint_ord_ore. +--! @param state public.eql_v3_smallint_ord_ore +--! @param value public.eql_v3_smallint_ord_ore +--! @return public.eql_v3_smallint_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord_ore, value public.eql_v3_smallint_ord_ore) +RETURNS public.eql_v3_smallint_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ore. ---! @param a eql_v3.query_double_ord_ore ---! @param b public.eql_v3_double_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +--! @brief min aggregate for public.eql_v3_smallint_ord_ore. +--! @param input public.eql_v3_smallint_ord_ore +--! @return public.eql_v3_smallint_ord_ore +CREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_smallint_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.eql_v3_smallint_ord_ore. +--! @param state public.eql_v3_smallint_ord_ore +--! @param value public.eql_v3_smallint_ord_ore +--! @return public.eql_v3_smallint_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord_ore, value public.eql_v3_smallint_ord_ore) +RETURNS public.eql_v3_smallint_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.eql_v3_smallint_ord_ore. +--! @param input public.eql_v3_smallint_ord_ore +--! @return public.eql_v3_smallint_ord_ore +CREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_smallint_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/query_double_ord_functions.sql ---! @brief Functions for eql_v3.query_double_ord. +--! @file encrypted_domain/smallint/query_smallint_ord_ope_functions.sql +--! @brief Functions for eql_v3.query_smallint_ord_ope. ---! @brief Index extractor for eql_v3.query_double_ord. ---! @param a eql_v3.query_double_ord +--! @brief Index extractor for eql_v3.query_smallint_ord_ope. +--! @param a eql_v3.query_smallint_ord_ope --! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_double_ord) +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_smallint_ord_ope) RETURNS eql_v3_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b eql_v3.query_double_ord +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b eql_v3.query_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b eql_v3.query_double_ord) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord. ---! @param a eql_v3.query_double_ord ---! @param b public.eql_v3_double_ord +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. +--! @param a eql_v3.query_smallint_ord_ope +--! @param b public.eql_v3_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord, b public.eql_v3_double_ord) +CREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b eql_v3.query_double_ord +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b eql_v3.query_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b eql_v3.query_double_ord) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord. ---! @param a eql_v3.query_double_ord ---! @param b public.eql_v3_double_ord +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. +--! @param a eql_v3.query_smallint_ord_ope +--! @param b public.eql_v3_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord, b public.eql_v3_double_ord) +CREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b eql_v3.query_double_ord +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b eql_v3.query_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b eql_v3.query_double_ord) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord. ---! @param a eql_v3.query_double_ord ---! @param b public.eql_v3_double_ord +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. +--! @param a eql_v3.query_smallint_ord_ope +--! @param b public.eql_v3_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord, b public.eql_v3_double_ord) +CREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b eql_v3.query_double_ord +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b eql_v3.query_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b eql_v3.query_double_ord) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord. ---! @param a eql_v3.query_double_ord ---! @param b public.eql_v3_double_ord +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. +--! @param a eql_v3.query_smallint_ord_ope +--! @param b public.eql_v3_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord, b public.eql_v3_double_ord) +CREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b eql_v3.query_double_ord +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b eql_v3.query_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b eql_v3.query_double_ord) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord. ---! @param a eql_v3.query_double_ord ---! @param b public.eql_v3_double_ord +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. +--! @param a eql_v3.query_smallint_ord_ope +--! @param b public.eql_v3_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord, b public.eql_v3_double_ord) +CREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b eql_v3.query_double_ord +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. +--! @param a public.eql_v3_smallint_ord_ope +--! @param b eql_v3.query_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b eql_v3.query_double_ord) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord. ---! @param a eql_v3.query_double_ord ---! @param b public.eql_v3_double_ord +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. +--! @param a eql_v3.query_smallint_ord_ope +--! @param b public.eql_v3_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord, b public.eql_v3_double_ord) +CREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/query_double_ord_ope_functions.sql ---! @brief Functions for eql_v3.query_double_ord_ope. - ---! @brief Index extractor for eql_v3.query_double_ord_ope. ---! @param a eql_v3.query_double_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_double_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.query_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b eql_v3.query_double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_double_ord_ope. ---! @param a eql_v3.query_double_ord_ope ---! @param b public.eql_v3_double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b eql_v3.query_double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_double_ord_ope. ---! @param a eql_v3.query_double_ord_ope ---! @param b public.eql_v3_double_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +--! @file encrypted_domain/smallint/query_smallint_ord_ore_functions.sql +--! @brief Functions for eql_v3.query_smallint_ord_ore. ---! @brief Operator wrapper for eql_v3.query_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b eql_v3.query_double_ord_ope +--! @brief Index extractor for eql_v3.query_smallint_ord_ore. +--! @param a eql_v3.query_smallint_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_smallint_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore +--! @param b eql_v3.query_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ope. ---! @param a eql_v3.query_double_ord_ope ---! @param b public.eql_v3_double_ord_ope +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. +--! @param a eql_v3.query_smallint_ord_ore +--! @param b public.eql_v3_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope) +CREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b eql_v3.query_double_ord_ope +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore +--! @param b eql_v3.query_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ope. ---! @param a eql_v3.query_double_ord_ope ---! @param b public.eql_v3_double_ord_ope +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. +--! @param a eql_v3.query_smallint_ord_ore +--! @param b public.eql_v3_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope) +CREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b eql_v3.query_double_ord_ope +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore +--! @param b eql_v3.query_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ope. ---! @param a eql_v3.query_double_ord_ope ---! @param b public.eql_v3_double_ord_ope +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. +--! @param a eql_v3.query_smallint_ord_ore +--! @param b public.eql_v3_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope) +CREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b eql_v3.query_double_ord_ope +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore +--! @param b eql_v3.query_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ope. ---! @param a eql_v3.query_double_ord_ope ---! @param b public.eql_v3_double_ord_ope +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. +--! @param a eql_v3.query_smallint_ord_ore +--! @param b public.eql_v3_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope) +CREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/double/query_double_eq_functions.sql ---! @brief Functions for eql_v3.query_double_eq. - ---! @brief Index extractor for eql_v3.query_double_eq. ---! @param a eql_v3.query_double_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_double_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b eql_v3.query_double_eq +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore +--! @param b eql_v3.query_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b eql_v3.query_double_eq) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_eq. ---! @param a eql_v3.query_double_eq ---! @param b public.eql_v3_double_eq +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. +--! @param a eql_v3.query_smallint_ord_ore +--! @param b public.eql_v3_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_double_eq, b public.eql_v3_double_eq) +CREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b eql_v3.query_double_eq +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. +--! @param a public.eql_v3_smallint_ord_ore +--! @param b eql_v3.query_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b eql_v3.query_double_eq) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_eq. ---! @param a eql_v3.query_double_eq ---! @param b public.eql_v3_double_eq +--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. +--! @param a eql_v3.query_smallint_ord_ore +--! @param b public.eql_v3_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_double_eq, b public.eql_v3_double_eq) +CREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/double_ord_ore_operators.sql ---! @brief Operators for public.eql_v3_double_ord_ore. +--! @file encrypted_domain/smallint/smallint_ord_operators.sql +--! @brief Operators for public.eql_v3_smallint_ord. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/query_smallint_eq_operators.sql +--! @brief Operators for eql_v3.query_smallint_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = eql_v3.query_smallint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = eql_v3.query_smallint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/query_smallint_ord_operators.sql +--! @brief Operators for eql_v3.query_smallint_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_operators.sql +--! @brief Operators for public.eql_v3_smallint. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb +); + CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore + LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore + LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_smallint, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_smallint, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_smallint, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_smallint, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_smallint, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text + LEFTARG = public.eql_v3_smallint, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer + LEFTARG = public.eql_v3_smallint, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore + LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb + LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/double_ord_ope_operators.sql ---! @brief Operators for public.eql_v3_double_ord_ope. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @file encrypted_domain/smallint/query_smallint_ord_ope_operators.sql +--! @brief Operators for eql_v3.query_smallint_ord_ope. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope, + LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope, + LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope, + LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope, + LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope, + LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope, + LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope -); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/double_ord_operators.sql ---! @brief Operators for public.eql_v3_double_ord. +--! @file encrypted_domain/smallint/smallint_eq_operators.sql +--! @brief Operators for public.eql_v3_smallint_eq. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = text + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = text + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = text + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = text + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[] ); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/double/double_functions.sql ---! @brief Functions for public.eql_v3_double. - ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b public.eql_v3_double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b public.eql_v3_double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[] +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b public.eql_v3_double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b public.eql_v3_double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/smallint/smallint_ord_ope_aggregates.sql +--! @brief Aggregates for public.eql_v3_smallint_ord_ope. ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +--! @brief State function for min on public.eql_v3_smallint_ord_ope. +--! @param state public.eql_v3_smallint_ord_ope +--! @param value public.eql_v3_smallint_ord_ope +--! @return public.eql_v3_smallint_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord_ope, value public.eql_v3_smallint_ord_ope) +RETURNS public.eql_v3_smallint_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +--! @brief min aggregate for public.eql_v3_smallint_ord_ope. +--! @param input public.eql_v3_smallint_ord_ope +--! @return public.eql_v3_smallint_ord_ope +CREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_smallint_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b public.eql_v3_double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +--! @brief State function for max on public.eql_v3_smallint_ord_ope. +--! @param state public.eql_v3_smallint_ord_ope +--! @param value public.eql_v3_smallint_ord_ope +--! @return public.eql_v3_smallint_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord_ope, value public.eql_v3_smallint_ord_ope) +RETURNS public.eql_v3_smallint_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +--! @brief max aggregate for public.eql_v3_smallint_ord_ope. +--! @param input public.eql_v3_smallint_ord_ope +--! @return public.eql_v3_smallint_ord_ope +CREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_smallint_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/smallint/query_smallint_ord_ore_operators.sql +--! @brief Operators for eql_v3.query_smallint_ord_ore. ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b public.eql_v3_double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b public.eql_v3_double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b public.eql_v3_double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param selector text ---! @return public.eql_v3_double -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double, selector text) -RETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param selector integer ---! @return public.eql_v3_double -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double, selector integer) -RETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param selector public.eql_v3_double ---! @return public.eql_v3_double -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double) -RETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/smallint/smallint_ord_aggregates.sql +--! @brief Aggregates for public.eql_v3_smallint_ord. ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +--! @brief State function for min on public.eql_v3_smallint_ord. +--! @param state public.eql_v3_smallint_ord +--! @param value public.eql_v3_smallint_ord +--! @return public.eql_v3_smallint_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord, value public.eql_v3_smallint_ord) +RETURNS public.eql_v3_smallint_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param selector public.eql_v3_double ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +--! @brief min aggregate for public.eql_v3_smallint_ord. +--! @param input public.eql_v3_smallint_ord +--! @return public.eql_v3_smallint_ord +CREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_smallint_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +--! @brief State function for max on public.eql_v3_smallint_ord. +--! @param state public.eql_v3_smallint_ord +--! @param value public.eql_v3_smallint_ord +--! @return public.eql_v3_smallint_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord, value public.eql_v3_smallint_ord) +RETURNS public.eql_v3_smallint_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +--! @brief max aggregate for public.eql_v3_smallint_ord. +--! @param input public.eql_v3_smallint_ord +--! @return public.eql_v3_smallint_ord +CREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_smallint_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/date/query_date_ord_operators.sql +--! @brief Operators for eql_v3.query_date_ord. ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double, b public.eql_v3_double) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); -- AUTOMATICALLY GENERATED FILE. --! @file encrypted_domain/date/query_date_ord_ore_functions.sql @@ -29855,114 +34003,6 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/query_date_ord_functions.sql ---! @brief Functions for eql_v3.query_date_ord. - ---! @brief Index extractor for eql_v3.query_date_ord. ---! @param a eql_v3.query_date_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_date_ord) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.query_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b eql_v3.query_date_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b eql_v3.query_date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_date_ord. ---! @param a eql_v3.query_date_ord ---! @param b public.eql_v3_date_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord, b public.eql_v3_date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b eql_v3.query_date_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b eql_v3.query_date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_date_ord. ---! @param a eql_v3.query_date_ord ---! @param b public.eql_v3_date_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord, b public.eql_v3_date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b eql_v3.query_date_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b eql_v3.query_date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_date_ord. ---! @param a eql_v3.query_date_ord ---! @param b public.eql_v3_date_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord, b public.eql_v3_date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b eql_v3.query_date_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b eql_v3.query_date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_date_ord. ---! @param a eql_v3.query_date_ord ---! @param b public.eql_v3_date_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord, b public.eql_v3_date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b eql_v3.query_date_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b eql_v3.query_date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_date_ord. ---! @param a eql_v3.query_date_ord ---! @param b public.eql_v3_date_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord, b public.eql_v3_date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b eql_v3.query_date_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b eql_v3.query_date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_date_ord. ---! @param a eql_v3.query_date_ord ---! @param b public.eql_v3_date_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord, b public.eql_v3_date_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; --- AUTOMATICALLY GENERATED FILE. - --! @file encrypted_domain/date/query_date_ord_ope_functions.sql --! @brief Functions for eql_v3.query_date_ord_ope. @@ -30071,3706 +34111,2738 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/query_date_eq_functions.sql ---! @brief Functions for eql_v3.query_date_eq. - ---! @brief Index extractor for eql_v3.query_date_eq. ---! @param a eql_v3.query_date_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_date_eq) -RETURNS eql_v3_internal.hmac_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; - ---! @brief Operator wrapper for eql_v3.query_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b eql_v3.query_date_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b eql_v3.query_date_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_date_eq. ---! @param a eql_v3.query_date_eq ---! @param b public.eql_v3_date_eq ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_date_eq, b public.eql_v3_date_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b eql_v3.query_date_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b eql_v3.query_date_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_date_eq. ---! @param a eql_v3.query_date_eq ---! @param b public.eql_v3_date_eq ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_date_eq, b public.eql_v3_date_eq) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/date/date_ord_ore_operators.sql ---! @brief Operators for public.eql_v3_date_ord_ore. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/date/date_ord_ope_operators.sql ---! @brief Operators for public.eql_v3_date_ord_ope. +--! @file encrypted_domain/date/date_eq_operators.sql +--! @brief Operators for public.eql_v3_date_eq. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope + LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb + LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope + LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb + LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_date_eq, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer + LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_date_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer + LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_date_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text + LEFTARG = public.eql_v3_date_eq, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer + LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[] + LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope + LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb + LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/date_ord_operators.sql ---! @brief Operators for public.eql_v3_date_ord. +--! @file encrypted_domain/date/date_operators.sql +--! @brief Operators for public.eql_v3_date. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.eql_v3_date, RIGHTARG = jsonb ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.eql_v3_date, RIGHTARG = jsonb ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_date, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_date, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_date, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_date, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord + LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_date, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord + LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_date, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = text + LEFTARG = public.eql_v3_date, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_date, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = text + LEFTARG = public.eql_v3_date, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_date, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = text + LEFTARG = public.eql_v3_date, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_date, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_date, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_date, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_date, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_date, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = text + LEFTARG = public.eql_v3_date, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_date, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_date, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_date, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord + LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_date, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/date_functions.sql ---! @brief Functions for public.eql_v3_date. - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b public.eql_v3_date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b public.eql_v3_date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b public.eql_v3_date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b public.eql_v3_date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b public.eql_v3_date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b public.eql_v3_date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b public.eql_v3_date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b public.eql_v3_date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param selector text ---! @return public.eql_v3_date -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date, selector text) -RETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/date/date_ord_ore_aggregates.sql +--! @brief Aggregates for public.eql_v3_date_ord_ore. ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param selector integer ---! @return public.eql_v3_date -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date, selector integer) -RETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; +--! @brief State function for min on public.eql_v3_date_ord_ore. +--! @param state public.eql_v3_date_ord_ore +--! @param value public.eql_v3_date_ord_ore +--! @return public.eql_v3_date_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord_ore, value public.eql_v3_date_ord_ore) +RETURNS public.eql_v3_date_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param selector public.eql_v3_date ---! @return public.eql_v3_date -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date) -RETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; +--! @brief min aggregate for public.eql_v3_date_ord_ore. +--! @param input public.eql_v3_date_ord_ore +--! @return public.eql_v3_date_ord_ore +CREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_date_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; +--! @brief State function for max on public.eql_v3_date_ord_ore. +--! @param state public.eql_v3_date_ord_ore +--! @param value public.eql_v3_date_ord_ore +--! @return public.eql_v3_date_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord_ore, value public.eql_v3_date_ord_ore) +RETURNS public.eql_v3_date_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; +--! @brief max aggregate for public.eql_v3_date_ord_ore. +--! @param input public.eql_v3_date_ord_ore +--! @return public.eql_v3_date_ord_ore +CREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_date_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param selector public.eql_v3_date ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/date/query_date_eq_functions.sql +--! @brief Functions for eql_v3.query_date_eq. ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; +--! @brief Index extractor for eql_v3.query_date_eq. +--! @param a eql_v3.query_date_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_date_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text[] +--! @brief Operator wrapper for eql_v3.query_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b eql_v3.query_date_eq --! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b eql_v3.query_date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text[] +--! @brief Operator wrapper for eql_v3.query_date_eq. +--! @param a eql_v3.query_date_eq +--! @param b public.eql_v3_date_eq --! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.eq(a eql_v3.query_date_eq, b public.eql_v3_date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonpath +--! @brief Operator wrapper for eql_v3.query_date_eq. +--! @param a public.eql_v3_date_eq +--! @param b eql_v3.query_date_eq --! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b eql_v3.query_date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonpath +--! @brief Operator wrapper for eql_v3.query_date_eq. +--! @param a eql_v3.query_date_eq +--! @param b public.eql_v3_date_eq --! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; +CREATE FUNCTION eql_v3.neq(a eql_v3.query_date_eq, b public.eql_v3_date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/date/date_ord_ope_aggregates.sql +--! @brief Aggregates for public.eql_v3_date_ord_ope. ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; +--! @brief State function for min on public.eql_v3_date_ord_ope. +--! @param state public.eql_v3_date_ord_ope +--! @param value public.eql_v3_date_ord_ope +--! @return public.eql_v3_date_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord_ope, value public.eql_v3_date_ord_ope) +RETURNS public.eql_v3_date_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date, b public.eql_v3_date) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; +--! @brief min aggregate for public.eql_v3_date_ord_ope. +--! @param input public.eql_v3_date_ord_ope +--! @return public.eql_v3_date_ord_ope +CREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_date_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; +--! @brief State function for max on public.eql_v3_date_ord_ope. +--! @param state public.eql_v3_date_ord_ope +--! @param value public.eql_v3_date_ord_ope +--! @return public.eql_v3_date_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord_ope, value public.eql_v3_date_ord_ope) +RETURNS public.eql_v3_date_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$ -LANGUAGE plpgsql; +--! @brief max aggregate for public.eql_v3_date_ord_ope. +--! @param input public.eql_v3_date_ord_ope +--! @return public.eql_v3_date_ord_ope +CREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_date_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/boolean/boolean_functions.sql ---! @brief Functions for public.eql_v3_boolean. - ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b public.eql_v3_boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/date/query_date_ord_ore_operators.sql +--! @brief Operators for eql_v3.query_date_ord_ore. ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b public.eql_v3_boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b public.eql_v3_boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b public.eql_v3_boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b public.eql_v3_boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/date/date_ord_operators.sql +--! @brief Operators for public.eql_v3_date_ord. ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b public.eql_v3_boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b public.eql_v3_boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b public.eql_v3_boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_boolean) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param selector text ---! @return public.eql_v3_boolean -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_boolean, selector text) -RETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param selector integer ---! @return public.eql_v3_boolean -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_boolean, selector integer) -RETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param selector public.eql_v3_boolean ---! @return public.eql_v3_boolean -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_boolean) -RETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_boolean, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_boolean, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param selector public.eql_v3_boolean ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_boolean) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_boolean, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_boolean, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_boolean, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_boolean, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_boolean, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_boolean, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_boolean, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_boolean, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_boolean, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_boolean, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_boolean, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_boolean, b public.eql_v3_boolean) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_boolean, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_boolean) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$ -LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer +); ---! @file encrypted_domain/bigint/query_bigint_ord_ore_functions.sql ---! @brief Functions for eql_v3.query_bigint_ord_ore. +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord +); ---! @brief Index extractor for eql_v3.query_bigint_ord_ore. ---! @param a eql_v3.query_bigint_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_bigint_ord_ore) -RETURNS eql_v3_internal.ore_block_256 -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = text +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b eql_v3.query_bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. ---! @param a eql_v3.query_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b eql_v3.query_bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonpath +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. ---! @param a eql_v3.query_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b eql_v3.query_bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. ---! @param a eql_v3.query_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b eql_v3.query_bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonpath +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. ---! @param a eql_v3.query_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b eql_v3.query_bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[] +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. ---! @param a eql_v3.query_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = text +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b eql_v3.query_bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. ---! @param a eql_v3.query_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[] +); ---! @file encrypted_domain/bigint/query_bigint_ord_functions.sql ---! @brief Functions for eql_v3.query_bigint_ord. +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[] +); ---! @brief Index extractor for eql_v3.query_bigint_ord. ---! @param a eql_v3.query_bigint_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_bigint_ord) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b eql_v3.query_bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord. ---! @param a eql_v3.query_bigint_ord ---! @param b public.eql_v3_bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Operator wrapper for eql_v3.query_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b eql_v3.query_bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +--! @file encrypted_domain/date/date_ord_aggregates.sql +--! @brief Aggregates for public.eql_v3_date_ord. ---! @brief Operator wrapper for eql_v3.query_bigint_ord. ---! @param a eql_v3.query_bigint_ord ---! @param b public.eql_v3_bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +--! @brief State function for min on public.eql_v3_date_ord. +--! @param state public.eql_v3_date_ord +--! @param value public.eql_v3_date_ord +--! @return public.eql_v3_date_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord, value public.eql_v3_date_ord) +RETURNS public.eql_v3_date_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b eql_v3.query_bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +--! @brief min aggregate for public.eql_v3_date_ord. +--! @param input public.eql_v3_date_ord +--! @return public.eql_v3_date_ord +CREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_date_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord. ---! @param a eql_v3.query_bigint_ord ---! @param b public.eql_v3_bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +--! @brief State function for max on public.eql_v3_date_ord. +--! @param state public.eql_v3_date_ord +--! @param value public.eql_v3_date_ord +--! @return public.eql_v3_date_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord, value public.eql_v3_date_ord) +RETURNS public.eql_v3_date_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b eql_v3.query_bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +--! @brief max aggregate for public.eql_v3_date_ord. +--! @param input public.eql_v3_date_ord +--! @return public.eql_v3_date_ord +CREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_date_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Operator wrapper for eql_v3.query_bigint_ord. ---! @param a eql_v3.query_bigint_ord ---! @param b public.eql_v3_bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +--! @file encrypted_domain/date/query_date_eq_operators.sql +--! @brief Operators for eql_v3.query_date_eq. ---! @brief Operator wrapper for eql_v3.query_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b eql_v3.query_bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_date_eq, RIGHTARG = eql_v3.query_date_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord. ---! @param a eql_v3.query_bigint_ord ---! @param b public.eql_v3_bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_date_eq, RIGHTARG = public.eql_v3_date_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b eql_v3.query_bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_date_eq, RIGHTARG = eql_v3.query_date_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord. ---! @param a eql_v3.query_bigint_ord ---! @param b public.eql_v3_bigint_ord ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_date_eq, RIGHTARG = public.eql_v3_date_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/bigint/query_bigint_ord_ope_functions.sql ---! @brief Functions for eql_v3.query_bigint_ord_ope. - ---! @brief Index extractor for eql_v3.query_bigint_ord_ope. ---! @param a eql_v3.query_bigint_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_bigint_ord_ope) -RETURNS eql_v3_internal.ope_cllw -LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +--! @file encrypted_domain/date/query_date_ord_ope_operators.sql +--! @brief Operators for eql_v3.query_date_ord_ope. ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b eql_v3.query_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. ---! @param a eql_v3.query_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b eql_v3.query_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. ---! @param a eql_v3.query_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b eql_v3.query_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. ---! @param a eql_v3.query_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b eql_v3.query_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. ---! @param a eql_v3.query_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b eql_v3.query_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. ---! @param a eql_v3.query_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b eql_v3.query_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. ---! @param a eql_v3.query_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/bigint/query_bigint_eq_functions.sql ---! @brief Functions for eql_v3.query_bigint_eq. +--! @file encrypted_domain/numeric/query_numeric_eq_functions.sql +--! @brief Functions for eql_v3.query_numeric_eq. ---! @brief Index extractor for eql_v3.query_bigint_eq. ---! @param a eql_v3.query_bigint_eq +--! @brief Index extractor for eql_v3.query_numeric_eq. +--! @param a eql_v3.query_numeric_eq --! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_bigint_eq) +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_numeric_eq) RETURNS eql_v3_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b eql_v3.query_bigint_eq +--! @brief Operator wrapper for eql_v3.query_numeric_eq. +--! @param a public.eql_v3_numeric_eq +--! @param b eql_v3.query_numeric_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b eql_v3.query_bigint_eq) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b eql_v3.query_numeric_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_eq. ---! @param a eql_v3.query_bigint_eq ---! @param b public.eql_v3_bigint_eq +--! @brief Operator wrapper for eql_v3.query_numeric_eq. +--! @param a eql_v3.query_numeric_eq +--! @param b public.eql_v3_numeric_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_eq, b public.eql_v3_bigint_eq) +CREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_eq, b public.eql_v3_numeric_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b eql_v3.query_bigint_eq +--! @brief Operator wrapper for eql_v3.query_numeric_eq. +--! @param a public.eql_v3_numeric_eq +--! @param b eql_v3.query_numeric_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b eql_v3.query_bigint_eq) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b eql_v3.query_numeric_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_eq. ---! @param a eql_v3.query_bigint_eq ---! @param b public.eql_v3_bigint_eq +--! @brief Operator wrapper for eql_v3.query_numeric_eq. +--! @param a eql_v3.query_numeric_eq +--! @param b public.eql_v3_numeric_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_eq, b public.eql_v3_bigint_eq) +CREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_eq, b public.eql_v3_numeric_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/bigint/bigint_ord_ore_operators.sql ---! @brief Operators for public.eql_v3_bigint_ord_ore. +--! @file encrypted_domain/numeric/query_numeric_ord_operators.sql +--! @brief Operators for eql_v3.query_numeric_ord. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb, + LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/query_numeric_ord_ore_operators.sql +--! @brief Operators for eql_v3.query_numeric_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore, + LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_functions.sql +--! @brief Functions for public.eql_v3_numeric. + +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b public.eql_v3_numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a jsonb +--! @param b public.eql_v3_numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b public.eql_v3_numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a jsonb +--! @param b public.eql_v3_numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b public.eql_v3_numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a jsonb +--! @param b public.eql_v3_numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b public.eql_v3_numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a jsonb +--! @param b public.eql_v3_numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b public.eql_v3_numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a jsonb +--! @param b public.eql_v3_numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b public.eql_v3_numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a jsonb +--! @param b public.eql_v3_numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b public.eql_v3_numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a jsonb +--! @param b public.eql_v3_numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b public.eql_v3_numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a jsonb +--! @param b public.eql_v3_numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param selector text +--! @return public.eql_v3_numeric +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric, selector text) +RETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param selector integer +--! @return public.eql_v3_numeric +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric, selector integer) +RETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a jsonb +--! @param selector public.eql_v3_numeric +--! @return public.eql_v3_numeric +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric) +RETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a jsonb +--! @param selector public.eql_v3_numeric +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b public.eql_v3_numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a jsonb +--! @param b public.eql_v3_numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b public.eql_v3_numeric +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric, b public.eql_v3_numeric) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a public.eql_v3_numeric +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore -); +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @param a jsonb +--! @param b public.eql_v3_numeric +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/bigint/bigint_ord_ope_operators.sql ---! @brief Operators for public.eql_v3_bigint_ord_ope. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @file encrypted_domain/numeric/query_numeric_ord_ope_operators.sql +--! @brief Operators for eql_v3.query_numeric_ord_ope. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope, + LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope, + LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope, + LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope, + LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope, + LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope -); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/bigint/bigint_ord_operators.sql ---! @brief Operators for public.eql_v3_bigint_ord. +--! @file encrypted_domain/numeric/numeric_eq_operators.sql +--! @brief Operators for public.eql_v3_numeric_eq. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[] + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/bigint/bigint_functions.sql ---! @brief Functions for public.eql_v3_bigint. - ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b public.eql_v3_bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b public.eql_v3_bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b public.eql_v3_bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; - ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b public.eql_v3_bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/numeric/numeric_ord_ore_aggregates.sql +--! @brief Aggregates for public.eql_v3_numeric_ord_ore. ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +--! @brief State function for min on public.eql_v3_numeric_ord_ore. +--! @param state public.eql_v3_numeric_ord_ore +--! @param value public.eql_v3_numeric_ord_ore +--! @return public.eql_v3_numeric_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord_ore, value public.eql_v3_numeric_ord_ore) +RETURNS public.eql_v3_numeric_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +--! @brief min aggregate for public.eql_v3_numeric_ord_ore. +--! @param input public.eql_v3_numeric_ord_ore +--! @return public.eql_v3_numeric_ord_ore +CREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_numeric_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b public.eql_v3_bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +--! @brief State function for max on public.eql_v3_numeric_ord_ore. +--! @param state public.eql_v3_numeric_ord_ore +--! @param value public.eql_v3_numeric_ord_ore +--! @return public.eql_v3_numeric_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord_ore, value public.eql_v3_numeric_ord_ore) +RETURNS public.eql_v3_numeric_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +--! @brief max aggregate for public.eql_v3_numeric_ord_ore. +--! @param input public.eql_v3_numeric_ord_ore +--! @return public.eql_v3_numeric_ord_ore +CREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_numeric_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +--! @file encrypted_domain/numeric/numeric_operators.sql +--! @brief Operators for public.eql_v3_numeric. ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b public.eql_v3_bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b public.eql_v3_bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b public.eql_v3_bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b jsonb) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param selector text ---! @return public.eql_v3_bigint -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint, selector text) -RETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param selector integer ---! @return public.eql_v3_bigint -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint, selector integer) -RETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param selector public.eql_v3_bigint ---! @return public.eql_v3_bigint -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint) -RETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param selector text ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint, selector text) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param selector integer ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint, selector integer) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param selector public.eql_v3_bigint ---! @return text -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text ---! @return boolean -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint, b text) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text[] ---! @return boolean -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint, b text[]) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonpath ---! @return boolean -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint, b jsonpath) -RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text[] ---! @return text -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint, b text[]) -RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint, b text) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b integer ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint, b integer) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_numeric, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text[] ---! @return jsonb -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint, b text[]) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_numeric, RIGHTARG = integer +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint, b public.eql_v3_bigint) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint, b jsonb) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_numeric, RIGHTARG = text +); ---! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return jsonb -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint) -RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$ -LANGUAGE plpgsql; +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_numeric, RIGHTARG = integer +); ---! @file v3/jsonb/functions.sql ---! @brief Extractors, containment engine, and path/array functions for the ---! eql_v3 encrypted-JSONB (SteVec) surface. ---! ---! `selector` parameters here are *encrypted-side* selector hashes — the ---! deterministic hash the crypto layer emits in the `s` field of each sv ---! element. Plaintext JSONPaths are never accepted at runtime. +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric +); ------------------------------------------------------------------------------- --- Envelope helpers (eql_v3 owns these; jsonb-only) ------------------------------------------------------------------------------- +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_numeric, RIGHTARG = text +); ---! @brief Extract metadata (i, v) from a raw jsonb encrypted value. ---! @param val jsonb encrypted EQL payload ---! @return jsonb Metadata object with `i` and `v` fields. -CREATE FUNCTION eql_v3.meta_data(val jsonb) - RETURNS jsonb - IMMUTABLE STRICT PARALLEL SAFE - LANGUAGE SQL -AS $$ - SELECT jsonb_build_object('i', val->'i', 'v', val->'v'); -$$; +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_numeric, RIGHTARG = text[] +); -COMMENT ON FUNCTION eql_v3.meta_data(jsonb) IS - 'eql-inline-critical: raw-jsonb envelope helper used by v3 jsonb wrappers; must stay inlinable (unpinned search_path)'; +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_numeric, RIGHTARG = text[] +); ---! @brief Extract ciphertext (c) from a raw jsonb encrypted value. ---! @param val jsonb encrypted EQL payload ---! @return text Base64-encoded ciphertext. ---! @throws Exception if `c` is absent. -CREATE FUNCTION eql_v3.ciphertext(val jsonb) - RETURNS text - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - BEGIN - IF val ? 'c' THEN - RETURN val->>'c'; - END IF; - RAISE 'Expected a ciphertext (c) value in json: %', val; - END; -$$ LANGUAGE plpgsql; +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonpath +); ------------------------------------------------------------------------------- --- Selector extractors ------------------------------------------------------------------------------- +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric +); ---! @brief Extract selector (s) from a raw jsonb encrypted value. ---! @param val jsonb encrypted EQL payload ---! @return text The selector value. ---! @throws Exception if `s` is absent. -CREATE FUNCTION eql_v3.selector(val jsonb) - RETURNS text - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - BEGIN - IF val ? 's' THEN - RETURN val->>'s'; - END IF; - RAISE 'Expected a selector index (s) value in json: %', val; - END; -$$ LANGUAGE plpgsql; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb +); ---! @brief Extract selector (s) from a ste_vec entry. The DOMAIN CHECK ---! guarantees `s` is present, so this is a simple field access. ---! @param entry public.eql_v3_jsonb_entry ---! @return text The selector value. -CREATE FUNCTION eql_v3.selector(entry public.eql_v3_jsonb_entry) - RETURNS text - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT entry ->> 's' -$$; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric +); ------------------------------------------------------------------------------- --- Equality-term extractor (XOR-aware: coalesce(hm, op)) ------------------------------------------------------------------------------- +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonpath +); ---! @brief XOR-aware equality term extractor for public.eql_v3_jsonb_entry. ---! ---! Returns the bytea of whichever deterministic term the sv entry carries — ---! `hm` (HMAC-256) or `op` (CLLW OPE). The two byte distributions are disjoint ---! by construction, so byte equality on the coalesce is unambiguous. Canonical ---! equality extractor used by `=` / `<>` on jsonb_entry. ---! ---! @param entry public.eql_v3_jsonb_entry ---! @return bytea Decoded `hm` or `op` bytes (NULL if entry is NULL). -CREATE FUNCTION eql_v3.eq_term(entry public.eql_v3_jsonb_entry) - RETURNS bytea - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT decode(coalesce(entry ->> 'hm', entry ->> 'op'), 'hex') -$$; +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_numeric, RIGHTARG = text[] +); ------------------------------------------------------------------------------- --- CLLW OPE per-entry overload (converged with the scalar ord_term) ------------------------------------------------------------------------------- +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_numeric, RIGHTARG = text[] +); ---! @brief Extract the CLLW OPE index term from a ste_vec entry. ---! ---! An sv-element `op` term is only ever present on an sv element, never at a ---! root encrypted value, so the typed overload accepts public.eql_v3_jsonb_entry — ---! the jsonb_entry twin of the generated scalar `eql_v3.ord_term` ---! extractors. Returns SQL NULL when `op` is absent (the strict `->>` / ---! `decode` chain propagates it), so btree NULL-filters such rows from range ---! queries. The returned eql_v3_internal.ope_cllw is a bytea domain: it orders ---! under native byte comparison with the DEFAULT btree opclass, so a ---! functional index on `eql_v3.ord_term(col -> 'selector')` engages ---! structurally with no custom operator class (Supabase/managed-Postgres ---! safe). ---! ---! @param entry public.eql_v3_jsonb_entry ---! @return eql_v3_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when ---! `op` is absent. -CREATE FUNCTION eql_v3.ord_term(entry public.eql_v3_jsonb_entry) - RETURNS eql_v3_internal.ope_cllw - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT eql_v3_internal.ope_cllw(entry::jsonb) -$$; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_numeric, RIGHTARG = text +); ------------------------------------------------------------------------------- --- sv-array helpers ------------------------------------------------------------------------------- +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_numeric, RIGHTARG = integer +); ---! @brief Extract the sv element array as raw jsonb[]. ---! ---! Returns the elements of `sv` (or a single-element array wrapping the value ---! when there is no `sv`). No envelope re-wrapping — raw jsonb elements. ---! ---! @param val jsonb encrypted EQL payload ---! @return jsonb[] Array of sv elements. -CREATE FUNCTION eql_v3.ste_vec(val jsonb) - RETURNS jsonb[] - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - DECLARE - sv jsonb; - ary jsonb[]; - BEGIN - IF val ? 'sv' THEN - sv := val->'sv'; - ELSE - sv := jsonb_build_array(val); - END IF; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_numeric, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_numeric, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric +); - SELECT array_agg(elem) - INTO ary - FROM jsonb_array_elements(sv) AS elem; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb +); - RETURN ary; - END; -$$ LANGUAGE plpgsql; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Check if a jsonb payload is marked as an sv array (`a` flag true). ---! @param val jsonb encrypted EQL payload ---! @return boolean True if `a` is present and true. -CREATE FUNCTION eql_v3_internal.is_ste_vec_array(val jsonb) - RETURNS boolean - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - BEGIN - IF val ? 'a' THEN - RETURN (val->>'a')::boolean; - END IF; - RETURN false; - END; -$$ LANGUAGE plpgsql; +--! @file encrypted_domain/numeric/query_numeric_eq_operators.sql +--! @brief Operators for eql_v3.query_numeric_eq. ------------------------------------------------------------------------------- --- Deterministic-fields array for GIN containment ------------------------------------------------------------------------------- +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = eql_v3.query_numeric_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Extract deterministic search fields (s, hm, op) per sv element. ---! ---! Excludes non-deterministic ciphertext so PostgreSQL's native jsonb `@>` can ---! compare for containment. Use for GIN indexes and containment queries. ---! ---! @param val jsonb encrypted EQL payload ---! @return jsonb[] Array of objects with only deterministic fields. -CREATE FUNCTION eql_v3.jsonb_array(val jsonb) -RETURNS jsonb[] -IMMUTABLE STRICT PARALLEL SAFE -LANGUAGE SQL -AS $$ - SELECT ARRAY( - SELECT jsonb_object_agg(kv.key, kv.value) - FROM jsonb_array_elements( - CASE WHEN val ? 'sv' THEN val->'sv' ELSE jsonb_build_array(val) END - ) AS elem, - LATERAL jsonb_each(elem) AS kv(key, value) - WHERE kv.key IN ('s', 'hm', 'op') - GROUP BY elem - ); -$$; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); -COMMENT ON FUNCTION eql_v3.jsonb_array(jsonb) IS - 'eql-inline-critical: raw-jsonb deterministic-field array helper; must stay inlinable (unpinned search_path)'; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = eql_v3.query_numeric_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); ------------------------------------------------------------------------------- --- Containment ------------------------------------------------------------------------------- +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief GIN-indexable containment check: does `a` contain all of `b`? ---! @param a jsonb Container payload. ---! @param b jsonb Search payload. ---! @return boolean True if a contains all deterministic elements of b. ---! @note Public raw-`jsonb[]` containment helper over the extracted ---! deterministic fields — the function-form entrypoint for containment on ---! platforms without operator support (Supabase/PostgREST). The typed ---! `public.eql_v3_json` `@>` operator does NOT call this function — it binds to ---! `eql_v3.ste_vec_contains` instead — but both agree on the result (a ---! parity test pins this). Also the documented GIN index expression ---! (`eql_v3.jsonb_array(col)`); see docs/reference/database-indexes.md. -CREATE FUNCTION eql_v3.jsonb_contains(a jsonb, b jsonb) -RETURNS boolean -IMMUTABLE STRICT PARALLEL SAFE -LANGUAGE SQL +--! @file encrypted_domain/numeric/numeric_ord_ope_aggregates.sql +--! @brief Aggregates for public.eql_v3_numeric_ord_ope. + +--! @brief State function for min on public.eql_v3_numeric_ord_ope. +--! @param state public.eql_v3_numeric_ord_ope +--! @param value public.eql_v3_numeric_ord_ope +--! @return public.eql_v3_numeric_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord_ope, value public.eql_v3_numeric_ord_ope) +RETURNS public.eql_v3_numeric_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public AS $$ - SELECT eql_v3.jsonb_array(a) @> eql_v3.jsonb_array(b); +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; $$; -COMMENT ON FUNCTION eql_v3.jsonb_contains(jsonb, jsonb) IS - 'eql-inline-critical: raw-jsonb containment helper; must stay inlinable (unpinned search_path)'; +--! @brief min aggregate for public.eql_v3_numeric_ord_ope. +--! @param input public.eql_v3_numeric_ord_ope +--! @return public.eql_v3_numeric_ord_ope +CREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_numeric_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); ---! @brief GIN-indexable "is contained by" check. ---! @param a jsonb Payload to check. ---! @param b jsonb Container payload. ---! @return boolean True if all elements of a are contained in b. ---! @note Public raw-`jsonb[]` reverse-containment helper — the function-form ---! entrypoint for `<@` on platforms without operator support. The typed ---! `public.eql_v3_json` `<@` operator binds to `eql_v3.ste_vec_contains` instead, ---! but both agree on the result. -CREATE FUNCTION eql_v3.jsonb_contained_by(a jsonb, b jsonb) -RETURNS boolean -IMMUTABLE STRICT PARALLEL SAFE -LANGUAGE SQL +--! @brief State function for max on public.eql_v3_numeric_ord_ope. +--! @param state public.eql_v3_numeric_ord_ope +--! @param value public.eql_v3_numeric_ord_ope +--! @return public.eql_v3_numeric_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord_ope, value public.eql_v3_numeric_ord_ope) +RETURNS public.eql_v3_numeric_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public AS $$ - SELECT eql_v3.jsonb_array(a) <@ eql_v3.jsonb_array(b); +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; $$; -COMMENT ON FUNCTION eql_v3.jsonb_contained_by(jsonb, jsonb) IS - 'eql-inline-critical: raw-jsonb contained-by helper; must stay inlinable (unpinned search_path)'; +--! @brief max aggregate for public.eql_v3_numeric_ord_ope. +--! @param input public.eql_v3_numeric_ord_ope +--! @return public.eql_v3_numeric_ord_ope +CREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_numeric_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. ---! @brief Check if an sv array contains a specific sv element. ---! ---! Match = selector equal AND eq_term equal (byte-equality over coalesce(hm, ---! op)). This collapses the v2 hm/oc CASE: under the XOR contract both terms ---! are deterministic and byte-disjoint, so either one is a valid equality ---! discriminator and a single byte comparison is correct. ---! ---! ASSUMPTION (locked by a negative test in v3_jsonb_tests.rs): hm and op byte ---! distributions never collide at a given selector. The crypto layer configures ---! a selector for eq XOR ordered, so both sides of a real comparison carry the ---! same term type — an hm needle never meets an op leaf at the same selector. ---! This collapse would wrongly match an hm needle against an op leaf if their ---! hex bytes were ever identical — which the contract prevents (an hm is a ---! fixed 32-byte HMAC; an op is a CLLW OPE ciphertext whose length is a ---! function of the plaintext bit width, never 32 bytes for the supported ---! domains). The negative-containment test guards against regression. ---! ---! @param a jsonb[] sv array to search within. ---! @param b jsonb sv element to search for. ---! @return boolean True if b is found in any element of a. -CREATE FUNCTION eql_v3.ste_vec_contains(a jsonb[], b jsonb) - RETURNS boolean - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - DECLARE - result boolean; - _a jsonb; - BEGIN - result := false; +--! @file encrypted_domain/numeric/numeric_ord_operators.sql +--! @brief Operators for public.eql_v3_numeric_ord. - FOR idx IN 1..array_length(a, 1) LOOP - _a := a[idx]; - result := result OR ( - eql_v3.selector(_a) = eql_v3.selector(b) - AND eql_v3.eq_term(_a::public.eql_v3_jsonb_entry) = eql_v3.eq_term(b::public.eql_v3_jsonb_entry) - ); - EXIT WHEN result; - END LOOP; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - RETURN result; - END; -$$ LANGUAGE plpgsql; +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); ---! @brief Does encrypted value `a` contain all sv elements of `b`? ---! ---! Empty b is always contained. Each element of b must match selector + eq_term ---! in some element of a. ---! ---! @param a public.eql_v3_json Container. ---! @param b public.eql_v3_json Elements to find. ---! @return boolean True if all elements of b are contained in a. ---! @see eql_v3.ste_vec_contains(jsonb[], jsonb) -CREATE FUNCTION eql_v3.ste_vec_contains(a public.eql_v3_json, b public.eql_v3_json) - RETURNS boolean - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - DECLARE - result boolean; - sv_a jsonb[]; - sv_b jsonb[]; - _b jsonb; - BEGIN - sv_a := eql_v3.ste_vec(a); - sv_b := eql_v3.ste_vec(b); +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - IF array_length(sv_b, 1) IS NULL THEN - RETURN true; - END IF; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); - IF array_length(sv_a, 1) IS NULL THEN - RETURN false; - END IF; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); - result := true; +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); - FOR idx IN 1..array_length(sv_b, 1) LOOP - _b := sv_b[idx]; - result := result AND eql_v3.ste_vec_contains(sv_a, _b); - END LOOP; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); - RETURN result; - END; -$$ LANGUAGE plpgsql; +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ------------------------------------------------------------------------------- --- Path queries (text selector only) ------------------------------------------------------------------------------- +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); ---! @brief Query encrypted JSONB for sv elements matching `selector`. ---! ---! Returns one jsonb_entry row per matching encrypted element. Returns empty ---! set on no match. It deliberately does not wrap multiple matches as an ---! public.eql_v3_json document, because the root document domain requires an `sv` ---! array and single leaves belong to public.eql_v3_jsonb_entry. ---! ---! @param val jsonb encrypted EQL payload with `sv`. ---! @param selector text Selector hash (`s` value). ---! @return SETOF public.eql_v3_jsonb_entry Matching encrypted entries. ---! @see eql_v3.jsonb_path_query_first -CREATE FUNCTION eql_v3.jsonb_path_query(val jsonb, selector text) - RETURNS SETOF public.eql_v3_jsonb_entry - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_jsonb_entry - FROM jsonb_array_elements(val -> 'sv') elem - WHERE elem ->> 's' = selector -$$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); -COMMENT ON FUNCTION eql_v3.jsonb_path_query(jsonb, text) IS - 'eql-inline-critical: raw-jsonb path query helper; must stay inlinable (unpinned search_path)'; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); ---! @brief Check if a selector path exists in encrypted JSONB. ---! @param val jsonb encrypted EQL payload. ---! @param selector text Selector hash to test. ---! @return boolean True if a matching element exists. -CREATE FUNCTION eql_v3.jsonb_path_exists(val jsonb, selector text) - RETURNS boolean - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT EXISTS ( - SELECT 1 FROM jsonb_array_elements(val -> 'sv') elem - WHERE elem ->> 's' = selector - ); -$$; +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); -COMMENT ON FUNCTION eql_v3.jsonb_path_exists(jsonb, text) IS - 'eql-inline-critical: raw-jsonb path exists helper; must stay inlinable (unpinned search_path)'; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ---! @brief Get the first sv element matching `selector`, or NULL. ---! @param val jsonb encrypted EQL payload. ---! @param selector text Selector hash to match. ---! @return public.eql_v3_jsonb_entry First matching element or NULL. -CREATE FUNCTION eql_v3.jsonb_path_query_first(val jsonb, selector text) - RETURNS public.eql_v3_jsonb_entry - LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_jsonb_entry - FROM jsonb_array_elements(val -> 'sv') elem - WHERE elem ->> 's' = selector - LIMIT 1 -$$; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); -COMMENT ON FUNCTION eql_v3.jsonb_path_query_first(jsonb, text) IS - 'eql-inline-critical: raw-jsonb path first helper; must stay inlinable (unpinned search_path)'; +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); ------------------------------------------------------------------------------- --- Array functions ------------------------------------------------------------------------------- +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Get the length of an encrypted JSONB array. ---! @param val jsonb encrypted EQL payload (must have `a` flag true). ---! @return integer Number of elements. ---! @throws Exception 'cannot get array length of a non-array' if not an array. -CREATE FUNCTION eql_v3.jsonb_array_length(val jsonb) - RETURNS integer - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - DECLARE - sv jsonb[]; - BEGIN - IF eql_v3_internal.is_ste_vec_array(val) THEN - sv := eql_v3.ste_vec(val); - RETURN array_length(sv, 1); - END IF; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); - RAISE 'cannot get array length of a non-array'; - END; -$$ LANGUAGE plpgsql; +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); ---! @brief Extract elements of an encrypted JSONB array as rows. ---! @param val jsonb encrypted EQL payload (must have `a` flag true). ---! @return SETOF public.eql_v3_jsonb_entry One row per element (metadata preserved). ---! @throws Exception 'cannot extract elements from non-array' if not an array. -CREATE FUNCTION eql_v3.jsonb_array_elements(val jsonb) - RETURNS SETOF public.eql_v3_jsonb_entry - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - DECLARE - sv jsonb[]; - meta jsonb; - item jsonb; - BEGIN - IF NOT eql_v3_internal.is_ste_vec_array(val) THEN - RAISE 'cannot extract elements from non-array'; - END IF; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord +); - meta := eql_v3.meta_data(val); - sv := eql_v3.ste_vec(val); +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb +); - FOR idx IN 1..array_length(sv, 1) LOOP - item = sv[idx]; - RETURN NEXT (meta || item)::public.eql_v3_jsonb_entry; - END LOOP; +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord +); - RETURN; - END; -$$ LANGUAGE plpgsql; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord +); ---! @brief Extract elements of an encrypted JSONB array as ciphertext text. ---! @param val jsonb encrypted EQL payload (must have `a` flag true). ---! @return SETOF text One ciphertext per element. ---! @throws Exception 'cannot extract elements from non-array' if not an array. -CREATE FUNCTION eql_v3.jsonb_array_elements_text(val jsonb) - RETURNS SETOF text - IMMUTABLE STRICT PARALLEL SAFE - SET search_path = pg_catalog, extensions, public -AS $$ - DECLARE - sv jsonb[]; - BEGIN - IF NOT eql_v3_internal.is_ste_vec_array(val) THEN - RAISE 'cannot extract elements from non-array'; - END IF; +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb +); - sv := eql_v3.ste_vec(val); +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord +); - FOR idx IN 1..array_length(sv, 1) LOOP - RETURN NEXT eql_v3.ciphertext(sv[idx]); - END LOOP; +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text +); - RETURN; - END; -$$ LANGUAGE plpgsql; --- AUTOMATICALLY GENERATED FILE --- Source is src/v3/version.template +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[] +); -DROP FUNCTION IF EXISTS eql_v3.version(); +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonpath +); ---! @file v3/version.sql ---! @brief EQL version reporting (self-contained eql_v3 surface) ---! ---! This file is auto-generated from src/v3/version.template during build. ---! The 3.0.0 placeholder is replaced with the actual release ---! version (bare semver, e.g. "3.0.0") supplied via `mise run build --version`, ---! or "DEV" for development builds. +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord +); ---! @brief Get the installed EQL version string ---! ---! Returns the version string for the installed EQL library. This value is ---! baked in at build time from the release tag. ---! ---! @return text Version string (e.g. "3.0.0" or "DEV" for development builds) ---! ---! @note Auto-generated during build from src/v3/version.template ---! ---! Example: `SELECT eql_v3.version()` returns the installed version string, ---! e.g. `'3.0.0'` (or `'DEV'` for development builds). -CREATE FUNCTION eql_v3.version() - RETURNS text - IMMUTABLE STRICT PARALLEL SAFE -AS $$ - SELECT '3.0.0'; -$$ LANGUAGE SQL; +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb +); ---! @brief Schema-level version marker for obj_description() discoverability ---! ---! Mirrors eql_v3.version() as a comment on the schema so the installed ---! version can also be read via obj_description('eql_v3'::regnamespace). -COMMENT ON SCHEMA eql_v3 IS '3.0.0'; --- AUTOMATICALLY GENERATED FILE. +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord +); ---! @file encrypted_domain/timestamp/timestamp_ord_ore_aggregates.sql ---! @brief Aggregates for public.eql_v3_timestamp_ord_ore. +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonpath +); ---! @brief State function for min on public.eql_v3_timestamp_ord_ore. ---! @param state public.eql_v3_timestamp_ord_ore ---! @param value public.eql_v3_timestamp_ord_ore ---! @return public.eql_v3_timestamp_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord_ore, value public.eql_v3_timestamp_ord_ore) -RETURNS public.eql_v3_timestamp_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[] +); ---! @brief min aggregate for public.eql_v3_timestamp_ord_ore. ---! @param input public.eql_v3_timestamp_ord_ore ---! @return public.eql_v3_timestamp_ord_ore -CREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_timestamp_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[] ); ---! @brief State function for max on public.eql_v3_timestamp_ord_ore. ---! @param state public.eql_v3_timestamp_ord_ore ---! @param value public.eql_v3_timestamp_ord_ore ---! @return public.eql_v3_timestamp_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord_ore, value public.eql_v3_timestamp_ord_ore) -RETURNS public.eql_v3_timestamp_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text +); ---! @brief max aggregate for public.eql_v3_timestamp_ord_ore. ---! @param input public.eql_v3_timestamp_ord_ore ---! @return public.eql_v3_timestamp_ord_ore -CREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_timestamp_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer ); --- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/timestamp/timestamp_ord_ope_aggregates.sql ---! @brief Aggregates for public.eql_v3_timestamp_ord_ope. +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[] +); ---! @brief State function for min on public.eql_v3_timestamp_ord_ope. ---! @param state public.eql_v3_timestamp_ord_ope ---! @param value public.eql_v3_timestamp_ord_ope ---! @return public.eql_v3_timestamp_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord_ope, value public.eql_v3_timestamp_ord_ope) -RETURNS public.eql_v3_timestamp_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[] +); ---! @brief min aggregate for public.eql_v3_timestamp_ord_ope. ---! @param input public.eql_v3_timestamp_ord_ope ---! @return public.eql_v3_timestamp_ord_ope -CREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_timestamp_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord ); ---! @brief State function for max on public.eql_v3_timestamp_ord_ope. ---! @param state public.eql_v3_timestamp_ord_ope ---! @param value public.eql_v3_timestamp_ord_ope ---! @return public.eql_v3_timestamp_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord_ope, value public.eql_v3_timestamp_ord_ope) -RETURNS public.eql_v3_timestamp_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb +); ---! @brief max aggregate for public.eql_v3_timestamp_ord_ope. ---! @param input public.eql_v3_timestamp_ord_ope ---! @return public.eql_v3_timestamp_ord_ope -CREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_timestamp_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/timestamp/timestamp_ord_aggregates.sql ---! @brief Aggregates for public.eql_v3_timestamp_ord. +--! @file encrypted_domain/numeric/numeric_ord_aggregates.sql +--! @brief Aggregates for public.eql_v3_numeric_ord. ---! @brief State function for min on public.eql_v3_timestamp_ord. ---! @param state public.eql_v3_timestamp_ord ---! @param value public.eql_v3_timestamp_ord ---! @return public.eql_v3_timestamp_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord, value public.eql_v3_timestamp_ord) -RETURNS public.eql_v3_timestamp_ord +--! @brief State function for min on public.eql_v3_numeric_ord. +--! @param state public.eql_v3_numeric_ord +--! @param value public.eql_v3_numeric_ord +--! @return public.eql_v3_numeric_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord, value public.eql_v3_numeric_ord) +RETURNS public.eql_v3_numeric_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -33782,22 +36854,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_timestamp_ord. ---! @param input public.eql_v3_timestamp_ord ---! @return public.eql_v3_timestamp_ord -CREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord) ( +--! @brief min aggregate for public.eql_v3_numeric_ord. +--! @param input public.eql_v3_numeric_ord +--! @return public.eql_v3_numeric_ord +CREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord) ( sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_timestamp_ord, + stype = public.eql_v3_numeric_ord, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_timestamp_ord. ---! @param state public.eql_v3_timestamp_ord ---! @param value public.eql_v3_timestamp_ord ---! @return public.eql_v3_timestamp_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord, value public.eql_v3_timestamp_ord) -RETURNS public.eql_v3_timestamp_ord +--! @brief State function for max on public.eql_v3_numeric_ord. +--! @param state public.eql_v3_numeric_ord +--! @param value public.eql_v3_numeric_ord +--! @return public.eql_v3_numeric_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord, value public.eql_v3_numeric_ord) +RETURNS public.eql_v3_numeric_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -33809,910 +36881,1172 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_timestamp_ord. ---! @param input public.eql_v3_timestamp_ord ---! @return public.eql_v3_timestamp_ord -CREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord) ( +--! @brief max aggregate for public.eql_v3_numeric_ord. +--! @param input public.eql_v3_numeric_ord +--! @return public.eql_v3_numeric_ord +CREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord) ( sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_timestamp_ord, + stype = public.eql_v3_numeric_ord, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/timestamp/timestamp_operators.sql ---! @brief Operators for public.eql_v3_timestamp. +--! @file encrypted_domain/json/json_operators.sql +--! @brief Operators for public.eql_v3_json. CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp + LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp + LEFTARG = jsonb, RIGHTARG = public.eql_v3_json ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp + LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp + LEFTARG = jsonb, RIGHTARG = public.eql_v3_json ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp + LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_json, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_json, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_json, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_json, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_json, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_json, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_json, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_json, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_json, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_json, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_json, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_json, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_json, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_json ); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/boolean/boolean_types.sql +--! @brief Encrypted-domain types for boolean. + +DO $$ +BEGIN + --! @brief Encrypted domain public.eql_v3_boolean. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'eql_v3_boolean' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.eql_v3_boolean AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.eql_v3_boolean IS 'EQL encrypted boolean (storage only)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/boolean/boolean_functions.sql +--! @brief Functions for public.eql_v3_boolean. + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a jsonb +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a jsonb +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a jsonb +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a jsonb +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a jsonb +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a jsonb +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a jsonb +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a jsonb +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param selector text +--! @return public.eql_v3_boolean +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_boolean, selector text) +RETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param selector integer +--! @return public.eql_v3_boolean +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_boolean, selector integer) +RETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a jsonb +--! @param selector public.eql_v3_boolean +--! @return public.eql_v3_boolean +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_boolean) +RETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_boolean, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_boolean, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a jsonb +--! @param selector public.eql_v3_boolean +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_boolean) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_boolean, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_boolean, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_boolean, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_boolean, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_boolean, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonpath -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a jsonb +--! @param b public.eql_v3_boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_boolean, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_boolean, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = text -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_boolean, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_boolean, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_boolean, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[] -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_boolean, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_boolean, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b public.eql_v3_boolean +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_boolean, b public.eql_v3_boolean) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp -); +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a public.eql_v3_boolean +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_boolean, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @param a jsonb +--! @param b public.eql_v3_boolean +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_boolean) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/timestamp/timestamp_eq_operators.sql ---! @brief Operators for public.eql_v3_timestamp_eq. +--! @file encrypted_domain/boolean/boolean_operators.sql +--! @brief Operators for public.eql_v3_boolean. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq + LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq + LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq + LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq + LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq + LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq + LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text + LEFTARG = public.eql_v3_boolean, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_boolean, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text + LEFTARG = public.eql_v3_boolean, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_boolean, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text + LEFTARG = public.eql_v3_boolean, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_boolean, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_boolean, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_boolean, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_boolean, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text + LEFTARG = public.eql_v3_boolean, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_boolean, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_boolean, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_boolean, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq + LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/query_timestamp_ord_ore_operators.sql ---! @brief Operators for eql_v3.query_timestamp_ord_ore. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/timestamp/query_timestamp_ord_operators.sql ---! @brief Operators for eql_v3.query_timestamp_ord. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel + LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/timestamp/query_timestamp_ord_ope_operators.sql ---! @brief Operators for eql_v3.query_timestamp_ord_ope. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @file encrypted_domain/double/query_double_ord_functions.sql +--! @brief Functions for eql_v3.query_double_ord. -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Index extractor for eql_v3.query_double_ord. +--! @param a eql_v3.query_double_ord +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_double_ord) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for eql_v3.query_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b eql_v3.query_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b eql_v3.query_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for eql_v3.query_double_ord. +--! @param a eql_v3.query_double_ord +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord, b public.eql_v3_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for eql_v3.query_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b eql_v3.query_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b eql_v3.query_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for eql_v3.query_double_ord. +--! @param a eql_v3.query_double_ord +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord, b public.eql_v3_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for eql_v3.query_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b eql_v3.query_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b eql_v3.query_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Operator wrapper for eql_v3.query_double_ord. +--! @param a eql_v3.query_double_ord +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord, b public.eql_v3_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Operator wrapper for eql_v3.query_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b eql_v3.query_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b eql_v3.query_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @file encrypted_domain/timestamp/query_timestamp_eq_operators.sql ---! @brief Operators for eql_v3.query_timestamp_eq. +--! @brief Operator wrapper for eql_v3.query_double_ord. +--! @param a eql_v3.query_double_ord +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord, b public.eql_v3_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = eql_v3.query_timestamp_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b eql_v3.query_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b eql_v3.query_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_double_ord. +--! @param a eql_v3.query_double_ord +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord, b public.eql_v3_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = eql_v3.query_timestamp_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_double_ord. +--! @param a public.eql_v3_double_ord +--! @param b eql_v3.query_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b eql_v3.query_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_double_ord. +--! @param a eql_v3.query_double_ord +--! @param b public.eql_v3_double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord, b public.eql_v3_double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_search_ore_aggregates.sql ---! @brief Aggregates for public.eql_v3_text_search_ore. - ---! @brief State function for min on public.eql_v3_text_search_ore. ---! @param state public.eql_v3_text_search_ore ---! @param value public.eql_v3_text_search_ore ---! @return public.eql_v3_text_search_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_search_ore, value public.eql_v3_text_search_ore) -RETURNS public.eql_v3_text_search_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for public.eql_v3_text_search_ore. ---! @param input public.eql_v3_text_search_ore ---! @return public.eql_v3_text_search_ore -CREATE AGGREGATE eql_v3.min(public.eql_v3_text_search_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_text_search_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); +--! @file encrypted_domain/double/query_double_ord_ore_functions.sql +--! @brief Functions for eql_v3.query_double_ord_ore. ---! @brief State function for max on public.eql_v3_text_search_ore. ---! @param state public.eql_v3_text_search_ore ---! @param value public.eql_v3_text_search_ore ---! @return public.eql_v3_text_search_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_search_ore, value public.eql_v3_text_search_ore) -RETURNS public.eql_v3_text_search_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Index extractor for eql_v3.query_double_ord_ore. +--! @param a eql_v3.query_double_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_double_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; ---! @brief max aggregate for public.eql_v3_text_search_ore. ---! @param input public.eql_v3_text_search_ore ---! @return public.eql_v3_text_search_ore -CREATE AGGREGATE eql_v3.max(public.eql_v3_text_search_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_text_search_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Operator wrapper for eql_v3.query_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b eql_v3.query_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; ---! @file encrypted_domain/text/text_search_aggregates.sql ---! @brief Aggregates for public.eql_v3_text_search. +--! @brief Operator wrapper for eql_v3.query_double_ord_ore. +--! @param a eql_v3.query_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; ---! @brief State function for min on public.eql_v3_text_search. ---! @param state public.eql_v3_text_search ---! @param value public.eql_v3_text_search ---! @return public.eql_v3_text_search -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_search, value public.eql_v3_text_search) -RETURNS public.eql_v3_text_search -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Operator wrapper for eql_v3.query_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b eql_v3.query_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; ---! @brief min aggregate for public.eql_v3_text_search. ---! @param input public.eql_v3_text_search ---! @return public.eql_v3_text_search -CREATE AGGREGATE eql_v3.min(public.eql_v3_text_search) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_text_search, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); +--! @brief Operator wrapper for eql_v3.query_double_ord_ore. +--! @param a eql_v3.query_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; ---! @brief State function for max on public.eql_v3_text_search. ---! @param state public.eql_v3_text_search ---! @param value public.eql_v3_text_search ---! @return public.eql_v3_text_search -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_search, value public.eql_v3_text_search) -RETURNS public.eql_v3_text_search -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Operator wrapper for eql_v3.query_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b eql_v3.query_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief max aggregate for public.eql_v3_text_search. ---! @param input public.eql_v3_text_search ---! @return public.eql_v3_text_search -CREATE AGGREGATE eql_v3.max(public.eql_v3_text_search) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_text_search, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Operator wrapper for eql_v3.query_double_ord_ore. +--! @param a eql_v3.query_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @file encrypted_domain/text/text_ord_ore_aggregates.sql ---! @brief Aggregates for public.eql_v3_text_ord_ore. +--! @brief Operator wrapper for eql_v3.query_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b eql_v3.query_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief State function for min on public.eql_v3_text_ord_ore. ---! @param state public.eql_v3_text_ord_ore ---! @param value public.eql_v3_text_ord_ore ---! @return public.eql_v3_text_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord_ore, value public.eql_v3_text_ord_ore) -RETURNS public.eql_v3_text_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Operator wrapper for eql_v3.query_double_ord_ore. +--! @param a eql_v3.query_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief min aggregate for public.eql_v3_text_ord_ore. ---! @param input public.eql_v3_text_ord_ore ---! @return public.eql_v3_text_ord_ore -CREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_text_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); +--! @brief Operator wrapper for eql_v3.query_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b eql_v3.query_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief State function for max on public.eql_v3_text_ord_ore. ---! @param state public.eql_v3_text_ord_ore ---! @param value public.eql_v3_text_ord_ore ---! @return public.eql_v3_text_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord_ore, value public.eql_v3_text_ord_ore) -RETURNS public.eql_v3_text_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Operator wrapper for eql_v3.query_double_ord_ore. +--! @param a eql_v3.query_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief max aggregate for public.eql_v3_text_ord_ore. ---! @param input public.eql_v3_text_ord_ore ---! @return public.eql_v3_text_ord_ore -CREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_text_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); +--! @brief Operator wrapper for eql_v3.query_double_ord_ore. +--! @param a public.eql_v3_double_ord_ore +--! @param b eql_v3.query_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord_ore. +--! @param a eql_v3.query_double_ord_ore +--! @param b public.eql_v3_double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_ord_ope_aggregates.sql ---! @brief Aggregates for public.eql_v3_text_ord_ope. +--! @file encrypted_domain/double/double_ord_aggregates.sql +--! @brief Aggregates for public.eql_v3_double_ord. ---! @brief State function for min on public.eql_v3_text_ord_ope. ---! @param state public.eql_v3_text_ord_ope ---! @param value public.eql_v3_text_ord_ope ---! @return public.eql_v3_text_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord_ope, value public.eql_v3_text_ord_ope) -RETURNS public.eql_v3_text_ord_ope +--! @brief State function for min on public.eql_v3_double_ord. +--! @param state public.eql_v3_double_ord +--! @param value public.eql_v3_double_ord +--! @return public.eql_v3_double_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord, value public.eql_v3_double_ord) +RETURNS public.eql_v3_double_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -34724,22 +38058,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_text_ord_ope. ---! @param input public.eql_v3_text_ord_ope ---! @return public.eql_v3_text_ord_ope -CREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord_ope) ( +--! @brief min aggregate for public.eql_v3_double_ord. +--! @param input public.eql_v3_double_ord +--! @return public.eql_v3_double_ord +CREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord) ( sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_text_ord_ope, + stype = public.eql_v3_double_ord, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_text_ord_ope. ---! @param state public.eql_v3_text_ord_ope ---! @param value public.eql_v3_text_ord_ope ---! @return public.eql_v3_text_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord_ope, value public.eql_v3_text_ord_ope) -RETURNS public.eql_v3_text_ord_ope +--! @brief State function for max on public.eql_v3_double_ord. +--! @param state public.eql_v3_double_ord +--! @param value public.eql_v3_double_ord +--! @return public.eql_v3_double_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord, value public.eql_v3_double_ord) +RETURNS public.eql_v3_double_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -34751,26 +38085,26 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_text_ord_ope. ---! @param input public.eql_v3_text_ord_ope ---! @return public.eql_v3_text_ord_ope -CREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord_ope) ( +--! @brief max aggregate for public.eql_v3_double_ord. +--! @param input public.eql_v3_double_ord +--! @return public.eql_v3_double_ord +CREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord) ( sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_text_ord_ope, + stype = public.eql_v3_double_ord, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_ord_aggregates.sql ---! @brief Aggregates for public.eql_v3_text_ord. +--! @file encrypted_domain/double/double_ord_ope_aggregates.sql +--! @brief Aggregates for public.eql_v3_double_ord_ope. ---! @brief State function for min on public.eql_v3_text_ord. ---! @param state public.eql_v3_text_ord ---! @param value public.eql_v3_text_ord ---! @return public.eql_v3_text_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord, value public.eql_v3_text_ord) -RETURNS public.eql_v3_text_ord +--! @brief State function for min on public.eql_v3_double_ord_ope. +--! @param state public.eql_v3_double_ord_ope +--! @param value public.eql_v3_double_ord_ope +--! @return public.eql_v3_double_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord_ope, value public.eql_v3_double_ord_ope) +RETURNS public.eql_v3_double_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -34782,22 +38116,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_text_ord. ---! @param input public.eql_v3_text_ord ---! @return public.eql_v3_text_ord -CREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord) ( +--! @brief min aggregate for public.eql_v3_double_ord_ope. +--! @param input public.eql_v3_double_ord_ope +--! @return public.eql_v3_double_ord_ope +CREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord_ope) ( sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_text_ord, + stype = public.eql_v3_double_ord_ope, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_text_ord. ---! @param state public.eql_v3_text_ord ---! @param value public.eql_v3_text_ord ---! @return public.eql_v3_text_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord, value public.eql_v3_text_ord) -RETURNS public.eql_v3_text_ord +--! @brief State function for max on public.eql_v3_double_ord_ope. +--! @param state public.eql_v3_double_ord_ope +--! @param value public.eql_v3_double_ord_ope +--! @return public.eql_v3_double_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord_ope, value public.eql_v3_double_ord_ope) +RETURNS public.eql_v3_double_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -34809,1252 +38143,932 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_text_ord. ---! @param input public.eql_v3_text_ord ---! @return public.eql_v3_text_ord -CREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord) ( +--! @brief max aggregate for public.eql_v3_double_ord_ope. +--! @param input public.eql_v3_double_ord_ope +--! @return public.eql_v3_double_ord_ope +CREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord_ope) ( sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_text_ord, + stype = public.eql_v3_double_ord_ope, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_operators.sql ---! @brief Operators for public.eql_v3_text. +--! @file encrypted_domain/double/double_operators.sql +--! @brief Operators for public.eql_v3_double. CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text + LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_text, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double, RIGHTARG = jsonb ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text + LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_text, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double, RIGHTARG = jsonb ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text + LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_text, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text + LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_text, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text + LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_text, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text + LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_text, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text + LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_text, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text + LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_text, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text, RIGHTARG = text + LEFTARG = public.eql_v3_double, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text, RIGHTARG = integer + LEFTARG = public.eql_v3_double, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text, RIGHTARG = text + LEFTARG = public.eql_v3_double, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text, RIGHTARG = integer + LEFTARG = public.eql_v3_double, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_text, RIGHTARG = text + LEFTARG = public.eql_v3_double, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_text, RIGHTARG = text[] + LEFTARG = public.eql_v3_double, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_text, RIGHTARG = text[] + LEFTARG = public.eql_v3_double, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_text, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_double, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_text, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_text, RIGHTARG = text[] + LEFTARG = public.eql_v3_double, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_text, RIGHTARG = text[] + LEFTARG = public.eql_v3_double, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text, RIGHTARG = text + LEFTARG = public.eql_v3_double, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text, RIGHTARG = integer + LEFTARG = public.eql_v3_double, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text, RIGHTARG = text[] + LEFTARG = public.eql_v3_double, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_text, RIGHTARG = text[] + LEFTARG = public.eql_v3_double, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text + LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_match_operators.sql ---! @brief Operators for public.eql_v3_text_match. - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match -); +--! @file encrypted_domain/double/query_double_eq_operators.sql +--! @brief Operators for eql_v3.query_double_eq. CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_double_eq, RIGHTARG = eql_v3.query_double_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_double_eq, RIGHTARG = public.eql_v3_double_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_double_eq, RIGHTARG = eql_v3.query_double_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_match, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_match, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_match, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_match, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_text_match, RIGHTARG = text + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_double_eq, RIGHTARG = public.eql_v3_double_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_text_match, RIGHTARG = text[] -); +--! @file encrypted_domain/double/query_double_ord_ope_functions.sql +--! @brief Functions for eql_v3.query_double_ord_ope. -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_text_match, RIGHTARG = text[] -); +--! @brief Index extractor for eql_v3.query_double_ord_ope. +--! @param a eql_v3.query_double_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_double_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonpath -); +--! @brief Operator wrapper for eql_v3.query_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b eql_v3.query_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonpath -); +--! @brief Operator wrapper for eql_v3.query_double_ord_ope. +--! @param a eql_v3.query_double_ord_ope +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_text_match, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b eql_v3.query_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_text_match, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_double_ord_ope. +--! @param a eql_v3.query_double_ord_ope +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_match, RIGHTARG = text -); +--! @brief Operator wrapper for eql_v3.query_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b eql_v3.query_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_match, RIGHTARG = integer -); +--! @brief Operator wrapper for eql_v3.query_double_ord_ope. +--! @param a eql_v3.query_double_ord_ope +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_match, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b eql_v3.query_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_text_match, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_double_ord_ope. +--! @param a eql_v3.query_double_ord_ope +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match -); +--! @brief Operator wrapper for eql_v3.query_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b eql_v3.query_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb -); +--! @brief Operator wrapper for eql_v3.query_double_ord_ope. +--! @param a eql_v3.query_double_ord_ope +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match -); +--! @brief Operator wrapper for eql_v3.query_double_ord_ope. +--! @param a public.eql_v3_double_ord_ope +--! @param b eql_v3.query_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_double_ord_ope. +--! @param a eql_v3.query_double_ord_ope +--! @param b public.eql_v3_double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/text_eq_operators.sql ---! @brief Operators for public.eql_v3_text_eq. +--! @file encrypted_domain/double/double_eq_operators.sql +--! @brief Operators for public.eql_v3_double_eq. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq, + LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq, + LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq + LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq + LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq + LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq + LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq + LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq + LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = text + LEFTARG = public.eql_v3_double_eq, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = text + LEFTARG = public.eql_v3_double_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = text + LEFTARG = public.eql_v3_double_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = text + LEFTARG = public.eql_v3_double_eq, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq + LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/query_text_search_ore_operators.sql ---! @brief Operators for eql_v3.query_text_search_ore. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/query_text_search_operators.sql ---! @brief Operators for eql_v3.query_text_search. +--! @file encrypted_domain/double/query_double_ord_ore_operators.sql +--! @brief Operators for eql_v3.query_double_ord_ore. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/query_text_ord_ore_operators.sql ---! @brief Operators for eql_v3.query_text_ord_ore. +--! @file encrypted_domain/double/query_double_ord_operators.sql +--! @brief Operators for eql_v3.query_double_ord. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore, + LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/query_text_ord_operators.sql ---! @brief Operators for eql_v3.query_text_ord. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @file encrypted_domain/double/double_ord_ore_aggregates.sql +--! @brief Aggregates for public.eql_v3_double_ord_ore. -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief State function for min on public.eql_v3_double_ord_ore. +--! @param state public.eql_v3_double_ord_ore +--! @param value public.eql_v3_double_ord_ore +--! @return public.eql_v3_double_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord_ore, value public.eql_v3_double_ord_ore) +RETURNS public.eql_v3_double_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +--! @brief min aggregate for public.eql_v3_double_ord_ore. +--! @param input public.eql_v3_double_ord_ore +--! @return public.eql_v3_double_ord_ore +CREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_double_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe ); -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief State function for max on public.eql_v3_double_ord_ore. +--! @param state public.eql_v3_double_ord_ore +--! @param value public.eql_v3_double_ord_ore +--! @return public.eql_v3_double_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord_ore, value public.eql_v3_double_ord_ore) +RETURNS public.eql_v3_double_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +--! @brief max aggregate for public.eql_v3_double_ord_ore. +--! @param input public.eql_v3_double_ord_ore +--! @return public.eql_v3_double_ord_ore +CREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_double_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/query_text_ord_ope_operators.sql ---! @brief Operators for eql_v3.query_text_ord_ope. +--! @file encrypted_domain/double/query_double_ord_ope_operators.sql +--! @brief Operators for eql_v3.query_double_ord_ope. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, + LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, + LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, + LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, + LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, + LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope, + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, + LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/text/query_text_match_operators.sql ---! @brief Operators for eql_v3.query_text_match. - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = public.eql_v3_text_match, RIGHTARG = eql_v3.query_text_match, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = eql_v3.query_text_match, RIGHTARG = public.eql_v3_text_match, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = public.eql_v3_text_match, RIGHTARG = eql_v3.query_text_match, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.query_text_match, RIGHTARG = public.eql_v3_text_match, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/text/query_text_eq_operators.sql ---! @brief Operators for eql_v3.query_text_eq. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = eql_v3.query_text_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_text_eq, RIGHTARG = public.eql_v3_text_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = eql_v3.query_text_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_text_eq, RIGHTARG = public.eql_v3_text_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/smallint_ord_ore_aggregates.sql ---! @brief Aggregates for public.eql_v3_smallint_ord_ore. - ---! @brief State function for min on public.eql_v3_smallint_ord_ore. ---! @param state public.eql_v3_smallint_ord_ore ---! @param value public.eql_v3_smallint_ord_ore ---! @return public.eql_v3_smallint_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord_ore, value public.eql_v3_smallint_ord_ore) -RETURNS public.eql_v3_smallint_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for public.eql_v3_smallint_ord_ore. ---! @param input public.eql_v3_smallint_ord_ore ---! @return public.eql_v3_smallint_ord_ore -CREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_smallint_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on public.eql_v3_smallint_ord_ore. ---! @param state public.eql_v3_smallint_ord_ore ---! @param value public.eql_v3_smallint_ord_ore ---! @return public.eql_v3_smallint_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord_ore, value public.eql_v3_smallint_ord_ore) -RETURNS public.eql_v3_smallint_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for public.eql_v3_smallint_ord_ore. ---! @param input public.eql_v3_smallint_ord_ore ---! @return public.eql_v3_smallint_ord_ore -CREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_smallint_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/smallint_ord_ope_aggregates.sql ---! @brief Aggregates for public.eql_v3_smallint_ord_ope. +--! @file encrypted_domain/integer/integer_ord_aggregates.sql +--! @brief Aggregates for public.eql_v3_integer_ord. ---! @brief State function for min on public.eql_v3_smallint_ord_ope. ---! @param state public.eql_v3_smallint_ord_ope ---! @param value public.eql_v3_smallint_ord_ope ---! @return public.eql_v3_smallint_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord_ope, value public.eql_v3_smallint_ord_ope) -RETURNS public.eql_v3_smallint_ord_ope +--! @brief State function for min on public.eql_v3_integer_ord. +--! @param state public.eql_v3_integer_ord +--! @param value public.eql_v3_integer_ord +--! @return public.eql_v3_integer_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord, value public.eql_v3_integer_ord) +RETURNS public.eql_v3_integer_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -36066,22 +39080,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_smallint_ord_ope. ---! @param input public.eql_v3_smallint_ord_ope ---! @return public.eql_v3_smallint_ord_ope -CREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord_ope) ( +--! @brief min aggregate for public.eql_v3_integer_ord. +--! @param input public.eql_v3_integer_ord +--! @return public.eql_v3_integer_ord +CREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord) ( sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_smallint_ord_ope, + stype = public.eql_v3_integer_ord, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_smallint_ord_ope. ---! @param state public.eql_v3_smallint_ord_ope ---! @param value public.eql_v3_smallint_ord_ope ---! @return public.eql_v3_smallint_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord_ope, value public.eql_v3_smallint_ord_ope) -RETURNS public.eql_v3_smallint_ord_ope +--! @brief State function for max on public.eql_v3_integer_ord. +--! @param state public.eql_v3_integer_ord +--! @param value public.eql_v3_integer_ord +--! @return public.eql_v3_integer_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord, value public.eql_v3_integer_ord) +RETURNS public.eql_v3_integer_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -36093,26 +39107,26 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_smallint_ord_ope. ---! @param input public.eql_v3_smallint_ord_ope ---! @return public.eql_v3_smallint_ord_ope -CREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord_ope) ( +--! @brief max aggregate for public.eql_v3_integer_ord. +--! @param input public.eql_v3_integer_ord +--! @return public.eql_v3_integer_ord +CREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord) ( sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_smallint_ord_ope, + stype = public.eql_v3_integer_ord, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/smallint/smallint_ord_aggregates.sql ---! @brief Aggregates for public.eql_v3_smallint_ord. +--! @file encrypted_domain/integer/integer_ord_ore_aggregates.sql +--! @brief Aggregates for public.eql_v3_integer_ord_ore. ---! @brief State function for min on public.eql_v3_smallint_ord. ---! @param state public.eql_v3_smallint_ord ---! @param value public.eql_v3_smallint_ord ---! @return public.eql_v3_smallint_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord, value public.eql_v3_smallint_ord) -RETURNS public.eql_v3_smallint_ord +--! @brief State function for min on public.eql_v3_integer_ord_ore. +--! @param state public.eql_v3_integer_ord_ore +--! @param value public.eql_v3_integer_ord_ore +--! @return public.eql_v3_integer_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord_ore, value public.eql_v3_integer_ord_ore) +RETURNS public.eql_v3_integer_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -36124,22 +39138,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_smallint_ord. ---! @param input public.eql_v3_smallint_ord ---! @return public.eql_v3_smallint_ord -CREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord) ( +--! @brief min aggregate for public.eql_v3_integer_ord_ore. +--! @param input public.eql_v3_integer_ord_ore +--! @return public.eql_v3_integer_ord_ore +CREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord_ore) ( sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_smallint_ord, + stype = public.eql_v3_integer_ord_ore, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_smallint_ord. ---! @param state public.eql_v3_smallint_ord ---! @param value public.eql_v3_smallint_ord ---! @return public.eql_v3_smallint_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord, value public.eql_v3_smallint_ord) -RETURNS public.eql_v3_smallint_ord +--! @brief State function for max on public.eql_v3_integer_ord_ore. +--! @param state public.eql_v3_integer_ord_ore +--! @param value public.eql_v3_integer_ord_ore +--! @return public.eql_v3_integer_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord_ore, value public.eql_v3_integer_ord_ore) +RETURNS public.eql_v3_integer_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -36151,1611 +39165,1396 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_smallint_ord. ---! @param input public.eql_v3_smallint_ord ---! @return public.eql_v3_smallint_ord -CREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord) ( +--! @brief max aggregate for public.eql_v3_integer_ord_ore. +--! @param input public.eql_v3_integer_ord_ore +--! @return public.eql_v3_integer_ord_ore +CREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord_ore) ( sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_smallint_ord, + stype = public.eql_v3_integer_ord_ore, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/smallint/smallint_operators.sql ---! @brief Operators for public.eql_v3_smallint. - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_smallint, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_smallint, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_smallint, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_smallint, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_smallint, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_smallint, RIGHTARG = text[] -); +--! @file encrypted_domain/integer/query_integer_ord_ore_functions.sql +--! @brief Functions for eql_v3.query_integer_ord_ore. -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_smallint, RIGHTARG = text[] -); +--! @brief Index extractor for eql_v3.query_integer_ord_ore. +--! @param a eql_v3.query_integer_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_integer_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonpath -); +--! @brief Operator wrapper for eql_v3.query_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b eql_v3.query_integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonpath -); +--! @brief Operator wrapper for eql_v3.query_integer_ord_ore. +--! @param a eql_v3.query_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_smallint, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b eql_v3.query_integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_smallint, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_integer_ord_ore. +--! @param a eql_v3.query_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint, RIGHTARG = text -); +--! @brief Operator wrapper for eql_v3.query_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b eql_v3.query_integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint, RIGHTARG = integer -); +--! @brief Operator wrapper for eql_v3.query_integer_ord_ore. +--! @param a eql_v3.query_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b eql_v3.query_integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_smallint, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_integer_ord_ore. +--! @param a eql_v3.query_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint -); +--! @brief Operator wrapper for eql_v3.query_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b eql_v3.query_integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb -); +--! @brief Operator wrapper for eql_v3.query_integer_ord_ore. +--! @param a eql_v3.query_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint -); +--! @brief Operator wrapper for eql_v3.query_integer_ord_ore. +--! @param a public.eql_v3_integer_ord_ore +--! @param b eql_v3.query_integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_integer_ord_ore. +--! @param a eql_v3.query_integer_ord_ore +--! @param b public.eql_v3_integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/smallint/smallint_eq_operators.sql ---! @brief Operators for public.eql_v3_smallint_eq. +--! @file encrypted_domain/integer/integer_ord_ope_operators.sql +--! @brief Operators for public.eql_v3_integer_ord_ope. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/query_smallint_ord_ore_operators.sql ---! @brief Operators for eql_v3.query_smallint_ord_ore. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/query_smallint_ord_operators.sql ---! @brief Operators for eql_v3.query_smallint_ord. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/query_smallint_ord_ope_operators.sql ---! @brief Operators for eql_v3.query_smallint_ord_ope. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/smallint/query_smallint_eq_operators.sql ---! @brief Operators for eql_v3.query_smallint_eq. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = eql_v3.query_smallint_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = eql_v3.query_smallint_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/real_ord_ore_aggregates.sql ---! @brief Aggregates for public.eql_v3_real_ord_ore. - ---! @brief State function for min on public.eql_v3_real_ord_ore. ---! @param state public.eql_v3_real_ord_ore ---! @param value public.eql_v3_real_ord_ore ---! @return public.eql_v3_real_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord_ore, value public.eql_v3_real_ord_ore) -RETURNS public.eql_v3_real_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @file encrypted_domain/integer/query_integer_ord_ope_functions.sql +--! @brief Functions for eql_v3.query_integer_ord_ope. ---! @brief min aggregate for public.eql_v3_real_ord_ore. ---! @param input public.eql_v3_real_ord_ore ---! @return public.eql_v3_real_ord_ore -CREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_real_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); +--! @brief Index extractor for eql_v3.query_integer_ord_ope. +--! @param a eql_v3.query_integer_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_integer_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; ---! @brief State function for max on public.eql_v3_real_ord_ore. ---! @param state public.eql_v3_real_ord_ore ---! @param value public.eql_v3_real_ord_ore ---! @return public.eql_v3_real_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord_ore, value public.eql_v3_real_ord_ore) -RETURNS public.eql_v3_real_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Operator wrapper for eql_v3.query_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b eql_v3.query_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @brief max aggregate for public.eql_v3_real_ord_ore. ---! @param input public.eql_v3_real_ord_ore ---! @return public.eql_v3_real_ord_ore -CREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_real_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Operator wrapper for eql_v3.query_integer_ord_ope. +--! @param a eql_v3.query_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; ---! @file encrypted_domain/real/real_ord_ope_aggregates.sql ---! @brief Aggregates for public.eql_v3_real_ord_ope. +--! @brief Operator wrapper for eql_v3.query_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b eql_v3.query_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief State function for min on public.eql_v3_real_ord_ope. ---! @param state public.eql_v3_real_ord_ope ---! @param value public.eql_v3_real_ord_ope ---! @return public.eql_v3_real_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord_ope, value public.eql_v3_real_ord_ope) -RETURNS public.eql_v3_real_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Operator wrapper for eql_v3.query_integer_ord_ope. +--! @param a eql_v3.query_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; ---! @brief min aggregate for public.eql_v3_real_ord_ope. ---! @param input public.eql_v3_real_ord_ope ---! @return public.eql_v3_real_ord_ope -CREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_real_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); +--! @brief Operator wrapper for eql_v3.query_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b eql_v3.query_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief State function for max on public.eql_v3_real_ord_ope. ---! @param state public.eql_v3_real_ord_ope ---! @param value public.eql_v3_real_ord_ope ---! @return public.eql_v3_real_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord_ope, value public.eql_v3_real_ord_ope) -RETURNS public.eql_v3_real_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Operator wrapper for eql_v3.query_integer_ord_ope. +--! @param a eql_v3.query_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; ---! @brief max aggregate for public.eql_v3_real_ord_ope. ---! @param input public.eql_v3_real_ord_ope ---! @return public.eql_v3_real_ord_ope -CREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_real_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Operator wrapper for eql_v3.query_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b eql_v3.query_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @file encrypted_domain/real/real_ord_aggregates.sql ---! @brief Aggregates for public.eql_v3_real_ord. +--! @brief Operator wrapper for eql_v3.query_integer_ord_ope. +--! @param a eql_v3.query_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; ---! @brief State function for min on public.eql_v3_real_ord. ---! @param state public.eql_v3_real_ord ---! @param value public.eql_v3_real_ord ---! @return public.eql_v3_real_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord, value public.eql_v3_real_ord) -RETURNS public.eql_v3_real_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Operator wrapper for eql_v3.query_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b eql_v3.query_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief min aggregate for public.eql_v3_real_ord. ---! @param input public.eql_v3_real_ord ---! @return public.eql_v3_real_ord -CREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_real_ord, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); +--! @brief Operator wrapper for eql_v3.query_integer_ord_ope. +--! @param a eql_v3.query_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; ---! @brief State function for max on public.eql_v3_real_ord. ---! @param state public.eql_v3_real_ord ---! @param value public.eql_v3_real_ord ---! @return public.eql_v3_real_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord, value public.eql_v3_real_ord) -RETURNS public.eql_v3_real_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Operator wrapper for eql_v3.query_integer_ord_ope. +--! @param a public.eql_v3_integer_ord_ope +--! @param b eql_v3.query_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; ---! @brief max aggregate for public.eql_v3_real_ord. ---! @param input public.eql_v3_real_ord ---! @return public.eql_v3_real_ord -CREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_real_ord, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); +--! @brief Operator wrapper for eql_v3.query_integer_ord_ope. +--! @param a eql_v3.query_integer_ord_ope +--! @param b public.eql_v3_integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/real_operators.sql ---! @brief Operators for public.eql_v3_real. +--! @file encrypted_domain/integer/integer_operators.sql +--! @brief Operators for public.eql_v3_integer. CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real + LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_real, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real + LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_real, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real + LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_real, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real + LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_real, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real + LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_real, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real + LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_real, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real + LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_real, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real + LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_real, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_real, RIGHTARG = text + LEFTARG = public.eql_v3_integer, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_real, RIGHTARG = integer + LEFTARG = public.eql_v3_integer, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_real, RIGHTARG = text + LEFTARG = public.eql_v3_integer, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_real, RIGHTARG = integer + LEFTARG = public.eql_v3_integer, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_real, RIGHTARG = text + LEFTARG = public.eql_v3_integer, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_real, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_real, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_real, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_integer, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_real, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_real, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_real, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real, RIGHTARG = text + LEFTARG = public.eql_v3_integer, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real, RIGHTARG = integer + LEFTARG = public.eql_v3_integer, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_real, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real + LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_real, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/real_eq_operators.sql ---! @brief Operators for public.eql_v3_real_eq. +--! @file encrypted_domain/integer/query_integer_eq_operators.sql +--! @brief Operators for eql_v3.query_integer_eq. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq, + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = eql_v3.query_integer_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb, + LEFTARG = eql_v3.query_integer_eq, RIGHTARG = public.eql_v3_integer_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = eql_v3.query_integer_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_integer_eq, RIGHTARG = public.eql_v3_integer_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/query_integer_ord_functions.sql +--! @brief Functions for eql_v3.query_integer_ord. + +--! @brief Index extractor for eql_v3.query_integer_ord. +--! @param a eql_v3.query_integer_ord +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_integer_ord) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b eql_v3.query_integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_integer_ord. +--! @param a eql_v3.query_integer_ord +--! @param b public.eql_v3_integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b eql_v3.query_integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_integer_ord. +--! @param a eql_v3.query_integer_ord +--! @param b public.eql_v3_integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b eql_v3.query_integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_integer_ord. +--! @param a eql_v3.query_integer_ord +--! @param b public.eql_v3_integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b eql_v3.query_integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_integer_ord. +--! @param a eql_v3.query_integer_ord +--! @param b public.eql_v3_integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b eql_v3.query_integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_integer_ord. +--! @param a eql_v3.query_integer_ord +--! @param b public.eql_v3_integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_integer_ord. +--! @param a public.eql_v3_integer_ord +--! @param b eql_v3.query_integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_integer_ord. +--! @param a eql_v3.query_integer_ord +--! @param b public.eql_v3_integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/query_integer_ord_ore_operators.sql +--! @brief Operators for eql_v3.query_integer_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq, + LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb, + LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_eq_operators.sql +--! @brief Operators for public.eql_v3_integer_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq, + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = text + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = text + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = text + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = text + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/query_real_ord_ore_operators.sql ---! @brief Operators for eql_v3.query_real_ord_ore. +--! @file encrypted_domain/integer/query_integer_ord_operators.sql +--! @brief Operators for eql_v3.query_integer_ord. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore, + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/query_real_ord_operators.sql ---! @brief Operators for eql_v3.query_real_ord. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @file encrypted_domain/integer/integer_ord_ope_aggregates.sql +--! @brief Aggregates for public.eql_v3_integer_ord_ope. -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief State function for min on public.eql_v3_integer_ord_ope. +--! @param state public.eql_v3_integer_ord_ope +--! @param value public.eql_v3_integer_ord_ope +--! @return public.eql_v3_integer_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord_ope, value public.eql_v3_integer_ord_ope) +RETURNS public.eql_v3_integer_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +--! @brief min aggregate for public.eql_v3_integer_ord_ope. +--! @param input public.eql_v3_integer_ord_ope +--! @return public.eql_v3_integer_ord_ope +CREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_integer_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe ); -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief State function for max on public.eql_v3_integer_ord_ope. +--! @param state public.eql_v3_integer_ord_ope +--! @param value public.eql_v3_integer_ord_ope +--! @return public.eql_v3_integer_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord_ope, value public.eql_v3_integer_ord_ope) +RETURNS public.eql_v3_integer_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +--! @brief max aggregate for public.eql_v3_integer_ord_ope. +--! @param input public.eql_v3_integer_ord_ope +--! @return public.eql_v3_integer_ord_ope +CREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_integer_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/query_real_ord_ope_operators.sql ---! @brief Operators for eql_v3.query_real_ord_ope. +--! @file encrypted_domain/integer/query_integer_ord_ope_operators.sql +--! @brief Operators for eql_v3.query_integer_ord_ope. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope, + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/real/query_real_eq_operators.sql ---! @brief Operators for eql_v3.query_real_eq. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = eql_v3.query_real_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_real_eq, RIGHTARG = public.eql_v3_real_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = eql_v3.query_real_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_real_eq, RIGHTARG = public.eql_v3_real_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); --- AUTOMATICALLY GENERATED FILE. - --! @file v3/scalars/ore_fallback.sql --! @brief Disable the ORE-backed encrypted domains when the ORE operator class is absent (CIP-3468). --! @@ -37823,2162 +40622,2623 @@ BEGIN -- must not abort). Domain coercion still enforces the CHECK on every new -- cast/insert regardless of validation status. - ALTER DOMAIN public.eql_v3_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable - 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; + ALTER DOMAIN public.eql_v3_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN eql_v3.query_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN public.eql_v3_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN eql_v3.query_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN public.eql_v3_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN eql_v3.query_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN public.eql_v3_date_ord_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN eql_v3.query_date_ord_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN public.eql_v3_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN eql_v3.query_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN public.eql_v3_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN eql_v3.query_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN public.eql_v3_text_ord_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN eql_v3.query_text_ord_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN public.eql_v3_text_search_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN eql_v3.query_text_search_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN public.eql_v3_real_ord_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN eql_v3.query_real_ord_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN public.eql_v3_double_ord_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + ALTER DOMAIN eql_v3.query_double_ord_ore ADD CONSTRAINT eql_ore_unavailable + 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; + + 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'; +END; +$do$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/query_text_match_functions.sql +--! @brief Functions for eql_v3.query_text_match. + +--! @brief Index extractor for eql_v3.query_text_match. +--! @param a eql_v3.query_text_match +--! @return eql_v3_internal.bloom_filter +CREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_match) +RETURNS eql_v3_internal.bloom_filter +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_text_match. +--! @param a public.eql_v3_text_match +--! @param b eql_v3.query_text_match +--! @return boolean +CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b eql_v3.query_text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_match. +--! @param a eql_v3.query_text_match +--! @param b public.eql_v3_text_match +--! @return boolean +CREATE FUNCTION eql_v3.matches(a eql_v3.query_text_match, b public.eql_v3_text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_functions.sql +--! @brief Functions for public.eql_v3_text. + +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a jsonb +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a jsonb +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a jsonb +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a jsonb +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a jsonb +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN eql_v3.query_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN public.eql_v3_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a jsonb +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN eql_v3.query_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN public.eql_v3_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN eql_v3.query_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a jsonb +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN public.eql_v3_date_ord_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN eql_v3.query_date_ord_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN public.eql_v3_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a jsonb +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN eql_v3.query_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param selector text +--! @return public.eql_v3_text +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text, selector text) +RETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN public.eql_v3_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param selector integer +--! @return public.eql_v3_text +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text, selector integer) +RETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN eql_v3.query_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a jsonb +--! @param selector public.eql_v3_text +--! @return public.eql_v3_text +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text) +RETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN public.eql_v3_text_ord_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN eql_v3.query_text_ord_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN public.eql_v3_text_search_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a jsonb +--! @param selector public.eql_v3_text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN eql_v3.query_text_search_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN public.eql_v3_real_ord_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN eql_v3.query_real_ord_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN public.eql_v3_double_ord_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - ALTER DOMAIN eql_v3.query_double_ord_ore ADD CONSTRAINT eql_ore_unavailable - 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; +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; - 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'; -END; -$do$; --- AUTOMATICALLY GENERATED FILE. +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; ---! @file encrypted_domain/numeric/query_numeric_ord_ore_operators.sql ---! @brief Operators for eql_v3.query_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a jsonb +--! @param b public.eql_v3_text +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b public.eql_v3_text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text, b public.eql_v3_text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a public.eql_v3_text +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! @param a jsonb +--! @param b public.eql_v3_text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @file encrypted_domain/text/query_text_ord_ope_functions.sql +--! @brief Functions for eql_v3.query_text_ord_ope. -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Index extractor for eql_v3.query_text_ord_ope. +--! @param a eql_v3.query_text_ord_ope +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord_ope) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @file encrypted_domain/numeric/query_numeric_ord_operators.sql ---! @brief Operators for eql_v3.query_numeric_ord. +--! @brief Index extractor for eql_v3.query_text_ord_ope. +--! @param a eql_v3.query_text_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b eql_v3.query_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord_ope. +--! @param a eql_v3.query_text_ord_ope +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b eql_v3.query_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord_ope. +--! @param a eql_v3.query_text_ord_ope +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b eql_v3.query_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord_ope. +--! @param a eql_v3.query_text_ord_ope +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b eql_v3.query_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord_ope. +--! @param a eql_v3.query_text_ord_ope +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b eql_v3.query_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord_ope. +--! @param a eql_v3.query_text_ord_ope +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord_ope. +--! @param a public.eql_v3_text_ord_ope +--! @param b eql_v3.query_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Operator wrapper for eql_v3.query_text_ord_ope. +--! @param a eql_v3.query_text_ord_ope +--! @param b public.eql_v3_text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/numeric/query_numeric_ord_ope_operators.sql ---! @brief Operators for eql_v3.query_numeric_ord_ope. +--! @file encrypted_domain/text/query_text_ord_operators.sql +--! @brief Operators for eql_v3.query_text_ord. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope, + LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/numeric/query_numeric_eq_operators.sql ---! @brief Operators for eql_v3.query_numeric_eq. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = eql_v3.query_numeric_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = eql_v3.query_numeric_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_ord_ore_aggregates.sql ---! @brief Aggregates for public.eql_v3_numeric_ord_ore. - ---! @brief State function for min on public.eql_v3_numeric_ord_ore. ---! @param state public.eql_v3_numeric_ord_ore ---! @param value public.eql_v3_numeric_ord_ore ---! @return public.eql_v3_numeric_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord_ore, value public.eql_v3_numeric_ord_ore) -RETURNS public.eql_v3_numeric_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for public.eql_v3_numeric_ord_ore. ---! @param input public.eql_v3_numeric_ord_ore ---! @return public.eql_v3_numeric_ord_ore -CREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_numeric_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on public.eql_v3_numeric_ord_ore. ---! @param state public.eql_v3_numeric_ord_ore ---! @param value public.eql_v3_numeric_ord_ore ---! @return public.eql_v3_numeric_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord_ore, value public.eql_v3_numeric_ord_ore) -RETURNS public.eql_v3_numeric_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for public.eql_v3_numeric_ord_ore. ---! @param input public.eql_v3_numeric_ord_ore ---! @return public.eql_v3_numeric_ord_ore -CREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_numeric_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_ord_ope_aggregates.sql ---! @brief Aggregates for public.eql_v3_numeric_ord_ope. - ---! @brief State function for min on public.eql_v3_numeric_ord_ope. ---! @param state public.eql_v3_numeric_ord_ope ---! @param value public.eql_v3_numeric_ord_ope ---! @return public.eql_v3_numeric_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord_ope, value public.eql_v3_numeric_ord_ope) -RETURNS public.eql_v3_numeric_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for public.eql_v3_numeric_ord_ope. ---! @param input public.eql_v3_numeric_ord_ope ---! @return public.eql_v3_numeric_ord_ope -CREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_numeric_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on public.eql_v3_numeric_ord_ope. ---! @param state public.eql_v3_numeric_ord_ope ---! @param value public.eql_v3_numeric_ord_ope ---! @return public.eql_v3_numeric_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord_ope, value public.eql_v3_numeric_ord_ope) -RETURNS public.eql_v3_numeric_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for public.eql_v3_numeric_ord_ope. ---! @param input public.eql_v3_numeric_ord_ope ---! @return public.eql_v3_numeric_ord_ope -CREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_numeric_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. +--! @file encrypted_domain/text/query_text_eq_functions.sql +--! @brief Functions for eql_v3.query_text_eq. ---! @file encrypted_domain/numeric/numeric_ord_aggregates.sql ---! @brief Aggregates for public.eql_v3_numeric_ord. +--! @brief Index extractor for eql_v3.query_text_eq. +--! @param a eql_v3.query_text_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief State function for min on public.eql_v3_numeric_ord. ---! @param state public.eql_v3_numeric_ord ---! @param value public.eql_v3_numeric_ord ---! @return public.eql_v3_numeric_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord, value public.eql_v3_numeric_ord) -RETURNS public.eql_v3_numeric_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Operator wrapper for eql_v3.query_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b eql_v3.query_text_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b eql_v3.query_text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief min aggregate for public.eql_v3_numeric_ord. ---! @param input public.eql_v3_numeric_ord ---! @return public.eql_v3_numeric_ord -CREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_numeric_ord, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); +--! @brief Operator wrapper for eql_v3.query_text_eq. +--! @param a eql_v3.query_text_eq +--! @param b public.eql_v3_text_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_eq, b public.eql_v3_text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief State function for max on public.eql_v3_numeric_ord. ---! @param state public.eql_v3_numeric_ord ---! @param value public.eql_v3_numeric_ord ---! @return public.eql_v3_numeric_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord, value public.eql_v3_numeric_ord) -RETURNS public.eql_v3_numeric_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Operator wrapper for eql_v3.query_text_eq. +--! @param a public.eql_v3_text_eq +--! @param b eql_v3.query_text_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b eql_v3.query_text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief max aggregate for public.eql_v3_numeric_ord. ---! @param input public.eql_v3_numeric_ord ---! @return public.eql_v3_numeric_ord -CREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_numeric_ord, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); +--! @brief Operator wrapper for eql_v3.query_text_eq. +--! @param a eql_v3.query_text_eq +--! @param b public.eql_v3_text_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_eq, b public.eql_v3_text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/numeric/numeric_operators.sql ---! @brief Operators for public.eql_v3_numeric. - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric -); +--! @file encrypted_domain/text/text_match_operators.sql +--! @brief Operators for public.eql_v3_text_match. CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_numeric, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_numeric, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_numeric, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_numeric, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_numeric, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_numeric, RIGHTARG = text[] -); - -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_numeric, RIGHTARG = text[] -); - -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonpath -); - -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_numeric, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_numeric, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_numeric, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/numeric/numeric_eq_operators.sql ---! @brief Operators for public.eql_v3_numeric_eq. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb ); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq + LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq + LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq + LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq + LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq + LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq + LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text + LEFTARG = public.eql_v3_text_match, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_text_match, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text + LEFTARG = public.eql_v3_text_match, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_text_match, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text + LEFTARG = public.eql_v3_text_match, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_match, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_match, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match, + RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb, + RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match, + RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_match, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_match, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text + LEFTARG = public.eql_v3_text_match, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_text_match, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_match, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_match, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq + LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/integer/query_integer_ord_ore_operators.sql ---! @brief Operators for eql_v3.query_integer_ord_ore. +--! @file encrypted_domain/text/text_search_operators.sql +--! @brief Operators for public.eql_v3_text_search. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore, + LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore, + LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore, + LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore, + LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore, + LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore, + LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/integer/query_integer_ord_operators.sql ---! @brief Operators for eql_v3.query_integer_ord. -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search ); -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb ); -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search ); -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search ); -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb ); -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search ); -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_text_search, RIGHTARG = text ); -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_text_search, RIGHTARG = integer ); -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search ); -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_text_search, RIGHTARG = text ); -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_text_search, RIGHTARG = integer ); --- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/integer/query_integer_ord_ope_operators.sql ---! @brief Operators for eql_v3.query_integer_ord_ope. +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search +); -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_text_search, RIGHTARG = text ); -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_text_search, RIGHTARG = text[] ); -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_text_search, RIGHTARG = text[] ); -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonpath ); -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, + RESTRICT = contsel, JOIN = contjoinsel ); -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, + RESTRICT = contsel, JOIN = contjoinsel ); -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, + RESTRICT = contsel, JOIN = contjoinsel ); -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonpath ); -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_text_search, RIGHTARG = text[] ); -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_text_search, RIGHTARG = text[] ); -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_text_search, RIGHTARG = text ); -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_text_search, RIGHTARG = integer ); --- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/integer/query_integer_eq_operators.sql ---! @brief Operators for eql_v3.query_integer_eq. +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_text_search, RIGHTARG = text[] +); -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = eql_v3.query_integer_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_text_search, RIGHTARG = text[] ); -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_integer_eq, RIGHTARG = public.eql_v3_integer_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search ); -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = eql_v3.query_integer_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb ); -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_integer_eq, RIGHTARG = public.eql_v3_integer_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/integer/integer_ord_ore_aggregates.sql ---! @brief Aggregates for public.eql_v3_integer_ord_ore. +--! @file encrypted_domain/text/query_text_search_ore_functions.sql +--! @brief Functions for eql_v3.query_text_search_ore. + +--! @brief Index extractor for eql_v3.query_text_search_ore. +--! @param a eql_v3.query_text_search_ore +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_search_ore) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Index extractor for eql_v3.query_text_search_ore. +--! @param a eql_v3.query_text_search_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_text_search_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Index extractor for eql_v3.query_text_search_ore. +--! @param a eql_v3.query_text_search_ore +--! @return eql_v3_internal.bloom_filter +CREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_search_ore) +RETURNS eql_v3_internal.bloom_filter +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b eql_v3.query_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a eql_v3.query_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b eql_v3.query_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a eql_v3.query_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b eql_v3.query_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a eql_v3.query_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b eql_v3.query_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a eql_v3.query_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b eql_v3.query_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a eql_v3.query_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b eql_v3.query_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a eql_v3.query_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b eql_v3.query_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search_ore. +--! @param a eql_v3.query_text_search_ore +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.matches(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/query_text_ord_ore_functions.sql +--! @brief Functions for eql_v3.query_text_ord_ore. ---! @brief State function for min on public.eql_v3_integer_ord_ore. ---! @param state public.eql_v3_integer_ord_ore ---! @param value public.eql_v3_integer_ord_ore ---! @return public.eql_v3_integer_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord_ore, value public.eql_v3_integer_ord_ore) -RETURNS public.eql_v3_integer_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Index extractor for eql_v3.query_text_ord_ore. +--! @param a eql_v3.query_text_ord_ore +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord_ore) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; ---! @brief min aggregate for public.eql_v3_integer_ord_ore. ---! @param input public.eql_v3_integer_ord_ore ---! @return public.eql_v3_integer_ord_ore -CREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_integer_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); +--! @brief Index extractor for eql_v3.query_text_ord_ore. +--! @param a eql_v3.query_text_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_text_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; ---! @brief State function for max on public.eql_v3_integer_ord_ore. ---! @param state public.eql_v3_integer_ord_ore ---! @param value public.eql_v3_integer_ord_ore ---! @return public.eql_v3_integer_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord_ore, value public.eql_v3_integer_ord_ore) -RETURNS public.eql_v3_integer_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Operator wrapper for eql_v3.query_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b eql_v3.query_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @brief max aggregate for public.eql_v3_integer_ord_ore. ---! @param input public.eql_v3_integer_ord_ore ---! @return public.eql_v3_integer_ord_ore -CREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_integer_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Operator wrapper for eql_v3.query_text_ord_ore. +--! @param a eql_v3.query_text_ord_ore +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; ---! @file encrypted_domain/integer/integer_ord_ope_aggregates.sql ---! @brief Aggregates for public.eql_v3_integer_ord_ope. +--! @brief Operator wrapper for eql_v3.query_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b eql_v3.query_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief State function for min on public.eql_v3_integer_ord_ope. ---! @param state public.eql_v3_integer_ord_ope ---! @param value public.eql_v3_integer_ord_ope ---! @return public.eql_v3_integer_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord_ope, value public.eql_v3_integer_ord_ope) -RETURNS public.eql_v3_integer_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Operator wrapper for eql_v3.query_text_ord_ore. +--! @param a eql_v3.query_text_ord_ore +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; ---! @brief min aggregate for public.eql_v3_integer_ord_ope. ---! @param input public.eql_v3_integer_ord_ope ---! @return public.eql_v3_integer_ord_ope -CREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_integer_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); +--! @brief Operator wrapper for eql_v3.query_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b eql_v3.query_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief State function for max on public.eql_v3_integer_ord_ope. ---! @param state public.eql_v3_integer_ord_ope ---! @param value public.eql_v3_integer_ord_ope ---! @return public.eql_v3_integer_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord_ope, value public.eql_v3_integer_ord_ope) -RETURNS public.eql_v3_integer_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Operator wrapper for eql_v3.query_text_ord_ore. +--! @param a eql_v3.query_text_ord_ore +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; ---! @brief max aggregate for public.eql_v3_integer_ord_ope. ---! @param input public.eql_v3_integer_ord_ope ---! @return public.eql_v3_integer_ord_ope -CREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_integer_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Operator wrapper for eql_v3.query_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b eql_v3.query_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @file encrypted_domain/integer/integer_ord_aggregates.sql ---! @brief Aggregates for public.eql_v3_integer_ord. +--! @brief Operator wrapper for eql_v3.query_text_ord_ore. +--! @param a eql_v3.query_text_ord_ore +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; ---! @brief State function for min on public.eql_v3_integer_ord. ---! @param state public.eql_v3_integer_ord ---! @param value public.eql_v3_integer_ord ---! @return public.eql_v3_integer_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord, value public.eql_v3_integer_ord) -RETURNS public.eql_v3_integer_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Operator wrapper for eql_v3.query_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b eql_v3.query_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief min aggregate for public.eql_v3_integer_ord. ---! @param input public.eql_v3_integer_ord ---! @return public.eql_v3_integer_ord -CREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_integer_ord, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); +--! @brief Operator wrapper for eql_v3.query_text_ord_ore. +--! @param a eql_v3.query_text_ord_ore +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; ---! @brief State function for max on public.eql_v3_integer_ord. ---! @param state public.eql_v3_integer_ord ---! @param value public.eql_v3_integer_ord ---! @return public.eql_v3_integer_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord, value public.eql_v3_integer_ord) -RETURNS public.eql_v3_integer_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Operator wrapper for eql_v3.query_text_ord_ore. +--! @param a public.eql_v3_text_ord_ore +--! @param b eql_v3.query_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; ---! @brief max aggregate for public.eql_v3_integer_ord. ---! @param input public.eql_v3_integer_ord ---! @return public.eql_v3_integer_ord -CREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_integer_ord, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); +--! @brief Operator wrapper for eql_v3.query_text_ord_ore. +--! @param a eql_v3.query_text_ord_ore +--! @param b public.eql_v3_text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/integer/integer_operators.sql ---! @brief Operators for public.eql_v3_integer. +--! @file encrypted_domain/text/text_search_ore_operators.sql +--! @brief Operators for public.eql_v3_text_search_ore. CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_integer, RIGHTARG = text + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_integer, RIGHTARG = integer + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_integer, RIGHTARG = text + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_integer, RIGHTARG = integer + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_integer, RIGHTARG = text + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_integer, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_integer, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_integer, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, + RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, + RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_integer, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_integer, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore ); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/query_text_search_functions.sql +--! @brief Functions for eql_v3.query_text_search. + +--! @brief Index extractor for eql_v3.query_text_search. +--! @param a eql_v3.query_text_search +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_search) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Index extractor for eql_v3.query_text_search. +--! @param a eql_v3.query_text_search +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_search) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Index extractor for eql_v3.query_text_search. +--! @param a eql_v3.query_text_search +--! @return eql_v3_internal.bloom_filter +CREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_search) +RETURNS eql_v3_internal.bloom_filter +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a public.eql_v3_text_search +--! @param b eql_v3.query_text_search +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b eql_v3.query_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a eql_v3.query_text_search +--! @param b public.eql_v3_text_search +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_search, b public.eql_v3_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a public.eql_v3_text_search +--! @param b eql_v3.query_text_search +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b eql_v3.query_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a eql_v3.query_text_search +--! @param b public.eql_v3_text_search +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_search, b public.eql_v3_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a public.eql_v3_text_search +--! @param b eql_v3.query_text_search +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b eql_v3.query_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a eql_v3.query_text_search +--! @param b public.eql_v3_text_search +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_search, b public.eql_v3_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_integer, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a public.eql_v3_text_search +--! @param b eql_v3.query_text_search +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b eql_v3.query_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer, RIGHTARG = text -); +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a eql_v3.query_text_search +--! @param b public.eql_v3_text_search +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_search, b public.eql_v3_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer, RIGHTARG = integer -); +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a public.eql_v3_text_search +--! @param b eql_v3.query_text_search +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b eql_v3.query_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a eql_v3.query_text_search +--! @param b public.eql_v3_text_search +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_search, b public.eql_v3_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_integer, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a public.eql_v3_text_search +--! @param b eql_v3.query_text_search +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b eql_v3.query_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer -); +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a eql_v3.query_text_search +--! @param b public.eql_v3_text_search +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_search, b public.eql_v3_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb -); +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a public.eql_v3_text_search +--! @param b eql_v3.query_text_search +--! @return boolean +CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b eql_v3.query_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer -); +--! @brief Operator wrapper for eql_v3.query_text_search. +--! @param a eql_v3.query_text_search +--! @param b public.eql_v3_text_search +--! @return boolean +CREATE FUNCTION eql_v3.matches(a eql_v3.query_text_search, b public.eql_v3_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/integer/integer_eq_operators.sql ---! @brief Operators for public.eql_v3_integer_eq. +--! @file encrypted_domain/text/text_eq_operators.sql +--! @brief Operators for public.eql_v3_text_eq. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq, + LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq, + LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq + LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq + LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq + LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq + LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq + LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq + LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text + LEFTARG = public.eql_v3_text_eq, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text + LEFTARG = public.eql_v3_text_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text + LEFTARG = public.eql_v3_text_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text + LEFTARG = public.eql_v3_text_eq, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq + LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/query_double_ord_ore_operators.sql ---! @brief Operators for eql_v3.query_double_ord_ore. +--! @file encrypted_domain/text/text_ord_ore_aggregates.sql +--! @brief Aggregates for public.eql_v3_text_ord_ore. + +--! @brief State function for min on public.eql_v3_text_ord_ore. +--! @param state public.eql_v3_text_ord_ore +--! @param value public.eql_v3_text_ord_ore +--! @return public.eql_v3_text_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord_ore, value public.eql_v3_text_ord_ore) +RETURNS public.eql_v3_text_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.eql_v3_text_ord_ore. +--! @param input public.eql_v3_text_ord_ore +--! @return public.eql_v3_text_ord_ore +CREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_text_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.eql_v3_text_ord_ore. +--! @param state public.eql_v3_text_ord_ore +--! @param value public.eql_v3_text_ord_ore +--! @return public.eql_v3_text_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord_ore, value public.eql_v3_text_ord_ore) +RETURNS public.eql_v3_text_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.eql_v3_text_ord_ore. +--! @param input public.eql_v3_text_ord_ore +--! @return public.eql_v3_text_ord_ore +CREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_text_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_aggregates.sql +--! @brief Aggregates for public.eql_v3_text_ord. + +--! @brief State function for min on public.eql_v3_text_ord. +--! @param state public.eql_v3_text_ord +--! @param value public.eql_v3_text_ord +--! @return public.eql_v3_text_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord, value public.eql_v3_text_ord) +RETURNS public.eql_v3_text_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.eql_v3_text_ord. +--! @param input public.eql_v3_text_ord +--! @return public.eql_v3_text_ord +CREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_text_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.eql_v3_text_ord. +--! @param state public.eql_v3_text_ord +--! @param value public.eql_v3_text_ord +--! @return public.eql_v3_text_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord, value public.eql_v3_text_ord) +RETURNS public.eql_v3_text_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.eql_v3_text_ord. +--! @param input public.eql_v3_text_ord +--! @return public.eql_v3_text_ord +CREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_text_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/query_text_ord_ope_operators.sql +--! @brief Operators for eql_v3.query_text_ord_ope. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/query_double_ord_operators.sql ---! @brief Operators for eql_v3.query_double_ord. +--! @file encrypted_domain/text/text_ord_ope_operators.sql +--! @brief Operators for public.eql_v3_text_ord_ope. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); --- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/query_double_ord_ope_operators.sql ---! @brief Operators for eql_v3.query_double_ord_ope. +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope ); -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb ); -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope ); -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope ); -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb ); -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope ); -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text ); -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer ); -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope ); -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope ); -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb ); -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope ); --- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/query_double_eq_operators.sql ---! @brief Operators for eql_v3.query_double_eq. +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonpath +); -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = eql_v3.query_double_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[] ); -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_double_eq, RIGHTARG = public.eql_v3_double_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[] ); -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = eql_v3.query_double_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text ); -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_double_eq, RIGHTARG = public.eql_v3_double_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer ); --- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/double_ord_ore_aggregates.sql ---! @brief Aggregates for public.eql_v3_double_ord_ore. +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[] +); ---! @brief State function for min on public.eql_v3_double_ord_ore. ---! @param state public.eql_v3_double_ord_ore ---! @param value public.eql_v3_double_ord_ore ---! @return public.eql_v3_double_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord_ore, value public.eql_v3_double_ord_ore) -RETURNS public.eql_v3_double_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[] +); ---! @brief min aggregate for public.eql_v3_double_ord_ore. ---! @param input public.eql_v3_double_ord_ore ---! @return public.eql_v3_double_ord_ore -CREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_double_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope ); ---! @brief State function for max on public.eql_v3_double_ord_ore. ---! @param state public.eql_v3_double_ord_ore ---! @param value public.eql_v3_double_ord_ore ---! @return public.eql_v3_double_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord_ore, value public.eql_v3_double_ord_ore) -RETURNS public.eql_v3_double_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb +); ---! @brief max aggregate for public.eql_v3_double_ord_ore. ---! @param input public.eql_v3_double_ord_ore ---! @return public.eql_v3_double_ord_ore -CREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_double_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/double_ord_ope_aggregates.sql ---! @brief Aggregates for public.eql_v3_double_ord_ope. +--! @file encrypted_domain/text/text_ord_ope_aggregates.sql +--! @brief Aggregates for public.eql_v3_text_ord_ope. ---! @brief State function for min on public.eql_v3_double_ord_ope. ---! @param state public.eql_v3_double_ord_ope ---! @param value public.eql_v3_double_ord_ope ---! @return public.eql_v3_double_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord_ope, value public.eql_v3_double_ord_ope) -RETURNS public.eql_v3_double_ord_ope +--! @brief State function for min on public.eql_v3_text_ord_ope. +--! @param state public.eql_v3_text_ord_ope +--! @param value public.eql_v3_text_ord_ope +--! @return public.eql_v3_text_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord_ope, value public.eql_v3_text_ord_ope) +RETURNS public.eql_v3_text_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -39990,22 +43250,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_double_ord_ope. ---! @param input public.eql_v3_double_ord_ope ---! @return public.eql_v3_double_ord_ope -CREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord_ope) ( +--! @brief min aggregate for public.eql_v3_text_ord_ope. +--! @param input public.eql_v3_text_ord_ope +--! @return public.eql_v3_text_ord_ope +CREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord_ope) ( sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_double_ord_ope, + stype = public.eql_v3_text_ord_ope, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_double_ord_ope. ---! @param state public.eql_v3_double_ord_ope ---! @param value public.eql_v3_double_ord_ope ---! @return public.eql_v3_double_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord_ope, value public.eql_v3_double_ord_ope) -RETURNS public.eql_v3_double_ord_ope +--! @brief State function for max on public.eql_v3_text_ord_ope. +--! @param state public.eql_v3_text_ord_ope +--! @param value public.eql_v3_text_ord_ope +--! @return public.eql_v3_text_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord_ope, value public.eql_v3_text_ord_ope) +RETURNS public.eql_v3_text_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -40017,910 +43277,1104 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_double_ord_ope. ---! @param input public.eql_v3_double_ord_ope ---! @return public.eql_v3_double_ord_ope -CREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord_ope) ( +--! @brief max aggregate for public.eql_v3_text_ord_ope. +--! @param input public.eql_v3_text_ord_ope +--! @return public.eql_v3_text_ord_ope +CREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord_ope) ( sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_double_ord_ope, + stype = public.eql_v3_text_ord_ope, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/double_ord_aggregates.sql ---! @brief Aggregates for public.eql_v3_double_ord. - ---! @brief State function for min on public.eql_v3_double_ord. ---! @param state public.eql_v3_double_ord ---! @param value public.eql_v3_double_ord ---! @return public.eql_v3_double_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord, value public.eql_v3_double_ord) -RETURNS public.eql_v3_double_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @file encrypted_domain/text/query_text_match_operators.sql +--! @brief Operators for eql_v3.query_text_match. ---! @brief min aggregate for public.eql_v3_double_ord. ---! @param input public.eql_v3_double_ord ---! @return public.eql_v3_double_ord -CREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_double_ord, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = public.eql_v3_text_match, RIGHTARG = eql_v3.query_text_match, + RESTRICT = contsel, JOIN = contjoinsel ); ---! @brief State function for max on public.eql_v3_double_ord. ---! @param state public.eql_v3_double_ord ---! @param value public.eql_v3_double_ord ---! @return public.eql_v3_double_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord, value public.eql_v3_double_ord) -RETURNS public.eql_v3_double_ord -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for public.eql_v3_double_ord. ---! @param input public.eql_v3_double_ord ---! @return public.eql_v3_double_ord -CREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_double_ord, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = eql_v3.query_text_match, RIGHTARG = public.eql_v3_text_match, + RESTRICT = contsel, JOIN = contjoinsel ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/double_operators.sql ---! @brief Operators for public.eql_v3_double. +--! @file encrypted_domain/text/text_operators.sql +--! @brief Operators for public.eql_v3_text. CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double + LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_double, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text, RIGHTARG = jsonb ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double + LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_double, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text, RIGHTARG = jsonb ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double + LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_double, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double + LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_double, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double + LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_double, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double + LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_double, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double + LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_double, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double + LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_double, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_double, RIGHTARG = text + LEFTARG = public.eql_v3_text, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_double, RIGHTARG = integer + LEFTARG = public.eql_v3_text, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_double, RIGHTARG = text + LEFTARG = public.eql_v3_text, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_double, RIGHTARG = integer + LEFTARG = public.eql_v3_text, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_double, RIGHTARG = text + LEFTARG = public.eql_v3_text, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_double, RIGHTARG = text[] + LEFTARG = public.eql_v3_text, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_double, RIGHTARG = text[] + LEFTARG = public.eql_v3_text, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_double, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_text, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_double, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_double, RIGHTARG = text[] + LEFTARG = public.eql_v3_text, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_double, RIGHTARG = text[] + LEFTARG = public.eql_v3_text, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double, RIGHTARG = text + LEFTARG = public.eql_v3_text, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double, RIGHTARG = integer + LEFTARG = public.eql_v3_text, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double, RIGHTARG = text[] + LEFTARG = public.eql_v3_text, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_double, RIGHTARG = text[] + LEFTARG = public.eql_v3_text, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double + LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_double, RIGHTARG = jsonb + LEFTARG = public.eql_v3_text, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/double/double_eq_operators.sql ---! @brief Operators for public.eql_v3_double_eq. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq -); +--! @file encrypted_domain/text/text_search_aggregates.sql +--! @brief Aggregates for public.eql_v3_text_search. -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq -); +--! @brief State function for min on public.eql_v3_text_search. +--! @param state public.eql_v3_text_search +--! @param value public.eql_v3_text_search +--! @return public.eql_v3_text_search +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_search, value public.eql_v3_text_search) +RETURNS public.eql_v3_text_search +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb +--! @brief min aggregate for public.eql_v3_text_search. +--! @param input public.eql_v3_text_search +--! @return public.eql_v3_text_search +CREATE AGGREGATE eql_v3.min(public.eql_v3_text_search) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_text_search, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe ); -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq -); +--! @brief State function for max on public.eql_v3_text_search. +--! @param state public.eql_v3_text_search +--! @param value public.eql_v3_text_search +--! @return public.eql_v3_text_search +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_search, value public.eql_v3_text_search) +RETURNS public.eql_v3_text_search +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq +--! @brief max aggregate for public.eql_v3_text_search. +--! @param input public.eql_v3_text_search +--! @return public.eql_v3_text_search +CREATE AGGREGATE eql_v3.max(public.eql_v3_text_search) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_text_search, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe ); +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb -); +--! @file encrypted_domain/text/text_search_ore_aggregates.sql +--! @brief Aggregates for public.eql_v3_text_search_ore. -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq -); +--! @brief State function for min on public.eql_v3_text_search_ore. +--! @param state public.eql_v3_text_search_ore +--! @param value public.eql_v3_text_search_ore +--! @return public.eql_v3_text_search_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_search_ore, value public.eql_v3_text_search_ore) +RETURNS public.eql_v3_text_search_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq +--! @brief min aggregate for public.eql_v3_text_search_ore. +--! @param input public.eql_v3_text_search_ore +--! @return public.eql_v3_text_search_ore +CREATE AGGREGATE eql_v3.min(public.eql_v3_text_search_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_text_search_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe ); -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb -); +--! @brief State function for max on public.eql_v3_text_search_ore. +--! @param state public.eql_v3_text_search_ore +--! @param value public.eql_v3_text_search_ore +--! @return public.eql_v3_text_search_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_search_ore, value public.eql_v3_text_search_ore) +RETURNS public.eql_v3_text_search_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq +--! @brief max aggregate for public.eql_v3_text_search_ore. +--! @param input public.eql_v3_text_search_ore +--! @return public.eql_v3_text_search_ore +CREATE AGGREGATE eql_v3.max(public.eql_v3_text_search_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_text_search_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe ); +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = text -); +--! @file encrypted_domain/text/query_text_search_operators.sql +--! @brief Operators for eql_v3.query_text_search. -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = text +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = text +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[] +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[] +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonpath +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonpath +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[] +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[] +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = text +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + RESTRICT = contsel, JOIN = contjoinsel ); -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + RESTRICT = contsel, JOIN = contjoinsel ); +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[] -); +--! @file encrypted_domain/text/query_text_eq_operators.sql +--! @brief Operators for eql_v3.query_text_eq. -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[] +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_text_eq, RIGHTARG = eql_v3.query_text_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_text_eq, RIGHTARG = public.eql_v3_text_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_text_eq, RIGHTARG = eql_v3.query_text_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_text_eq, RIGHTARG = public.eql_v3_text_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/query_date_ord_ore_operators.sql ---! @brief Operators for eql_v3.query_date_ord_ore. +--! @file encrypted_domain/text/query_text_ord_ore_operators.sql +--! @brief Operators for eql_v3.query_text_ord_ore. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore, + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/query_date_ord_operators.sql ---! @brief Operators for eql_v3.query_date_ord. +--! @file encrypted_domain/text/query_text_search_ore_operators.sql +--! @brief Operators for eql_v3.query_text_search_ore. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord, + LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord, + LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord, + LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord, + LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord, + LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord, + LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/date/query_date_ord_ope_operators.sql ---! @brief Operators for eql_v3.query_date_ord_ope. -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, + RESTRICT = contsel, JOIN = contjoinsel ); -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + RESTRICT = contsel, JOIN = contjoinsel ); +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @file encrypted_domain/timestamp/timestamp_functions.sql +--! @brief Functions for public.eql_v3_timestamp. -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b public.eql_v3_timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a jsonb +--! @param b public.eql_v3_timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b public.eql_v3_timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a jsonb +--! @param b public.eql_v3_timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b public.eql_v3_timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a jsonb +--! @param b public.eql_v3_timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b public.eql_v3_timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a jsonb +--! @param b public.eql_v3_timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b public.eql_v3_timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a jsonb +--! @param b public.eql_v3_timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b public.eql_v3_timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a jsonb +--! @param b public.eql_v3_timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b public.eql_v3_timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a jsonb +--! @param b public.eql_v3_timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b public.eql_v3_timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a jsonb +--! @param b public.eql_v3_timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param selector text +--! @return public.eql_v3_timestamp +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp, selector text) +RETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param selector integer +--! @return public.eql_v3_timestamp +CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp, selector integer) +RETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a jsonb +--! @param selector public.eql_v3_timestamp +--! @return public.eql_v3_timestamp +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp) +RETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a jsonb +--! @param selector public.eql_v3_timestamp +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; ---! @file encrypted_domain/date/query_date_eq_operators.sql ---! @brief Operators for eql_v3.query_date_eq. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = eql_v3.query_date_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_date_eq, RIGHTARG = public.eql_v3_date_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b public.eql_v3_timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = eql_v3.query_date_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_date_eq, RIGHTARG = public.eql_v3_date_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a jsonb +--! @param b public.eql_v3_timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; ---! @file encrypted_domain/date/date_ord_ore_aggregates.sql ---! @brief Aggregates for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; ---! @brief State function for min on public.eql_v3_date_ord_ore. ---! @param state public.eql_v3_date_ord_ore ---! @param value public.eql_v3_date_ord_ore ---! @return public.eql_v3_date_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord_ore, value public.eql_v3_date_ord_ore) -RETURNS public.eql_v3_date_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; ---! @brief min aggregate for public.eql_v3_date_ord_ore. ---! @param input public.eql_v3_date_ord_ore ---! @return public.eql_v3_date_ord_ore -CREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_date_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; ---! @brief State function for max on public.eql_v3_date_ord_ore. ---! @param state public.eql_v3_date_ord_ore ---! @param value public.eql_v3_date_ord_ore ---! @return public.eql_v3_date_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord_ore, value public.eql_v3_date_ord_ore) -RETURNS public.eql_v3_date_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; ---! @brief max aggregate for public.eql_v3_date_ord_ore. ---! @param input public.eql_v3_date_ord_ore ---! @return public.eql_v3_date_ord_ore -CREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_date_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; ---! @file encrypted_domain/date/date_ord_ope_aggregates.sql ---! @brief Aggregates for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; ---! @brief State function for min on public.eql_v3_date_ord_ope. ---! @param state public.eql_v3_date_ord_ope ---! @param value public.eql_v3_date_ord_ope ---! @return public.eql_v3_date_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord_ope, value public.eql_v3_date_ord_ope) -RETURNS public.eql_v3_date_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; ---! @brief min aggregate for public.eql_v3_date_ord_ope. ---! @param input public.eql_v3_date_ord_ope ---! @return public.eql_v3_date_ord_ope -CREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_date_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b public.eql_v3_timestamp +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; ---! @brief State function for max on public.eql_v3_date_ord_ope. ---! @param state public.eql_v3_date_ord_ope ---! @param value public.eql_v3_date_ord_ope ---! @return public.eql_v3_date_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord_ope, value public.eql_v3_date_ord_ope) -RETURNS public.eql_v3_date_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a public.eql_v3_timestamp +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; ---! @brief max aggregate for public.eql_v3_date_ord_ope. ---! @param input public.eql_v3_date_ord_ope ---! @return public.eql_v3_date_ord_ope -CREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_date_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @param a jsonb +--! @param b public.eql_v3_timestamp +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/date_ord_aggregates.sql ---! @brief Aggregates for public.eql_v3_date_ord. +--! @file encrypted_domain/timestamp/timestamp_ord_aggregates.sql +--! @brief Aggregates for public.eql_v3_timestamp_ord. ---! @brief State function for min on public.eql_v3_date_ord. ---! @param state public.eql_v3_date_ord ---! @param value public.eql_v3_date_ord ---! @return public.eql_v3_date_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord, value public.eql_v3_date_ord) -RETURNS public.eql_v3_date_ord +--! @brief State function for min on public.eql_v3_timestamp_ord. +--! @param state public.eql_v3_timestamp_ord +--! @param value public.eql_v3_timestamp_ord +--! @return public.eql_v3_timestamp_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord, value public.eql_v3_timestamp_ord) +RETURNS public.eql_v3_timestamp_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -40932,22 +44386,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_date_ord. ---! @param input public.eql_v3_date_ord ---! @return public.eql_v3_date_ord -CREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord) ( +--! @brief min aggregate for public.eql_v3_timestamp_ord. +--! @param input public.eql_v3_timestamp_ord +--! @return public.eql_v3_timestamp_ord +CREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord) ( sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_date_ord, + stype = public.eql_v3_timestamp_ord, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_date_ord. ---! @param state public.eql_v3_date_ord ---! @param value public.eql_v3_date_ord ---! @return public.eql_v3_date_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord, value public.eql_v3_date_ord) -RETURNS public.eql_v3_date_ord +--! @brief State function for max on public.eql_v3_timestamp_ord. +--! @param state public.eql_v3_timestamp_ord +--! @param value public.eql_v3_timestamp_ord +--! @return public.eql_v3_timestamp_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord, value public.eql_v3_timestamp_ord) +RETURNS public.eql_v3_timestamp_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -40959,1076 +44413,757 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_date_ord. ---! @param input public.eql_v3_date_ord ---! @return public.eql_v3_date_ord -CREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord) ( +--! @brief max aggregate for public.eql_v3_timestamp_ord. +--! @param input public.eql_v3_timestamp_ord +--! @return public.eql_v3_timestamp_ord +CREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord) ( sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_date_ord, + stype = public.eql_v3_timestamp_ord, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/date_operators.sql ---! @brief Operators for public.eql_v3_date. - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_date, RIGHTARG = jsonb -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_date, RIGHTARG = jsonb -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_date, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_date, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_date, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_date, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_date, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_date, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_date, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_date, RIGHTARG = integer -); +--! @file encrypted_domain/timestamp/query_timestamp_ord_ore_functions.sql +--! @brief Functions for eql_v3.query_timestamp_ord_ore. -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date -); +--! @brief Index extractor for eql_v3.query_timestamp_ord_ore. +--! @param a eql_v3.query_timestamp_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_timestamp_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_date, RIGHTARG = text -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b eql_v3.query_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_date, RIGHTARG = integer -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. +--! @param a eql_v3.query_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b eql_v3.query_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_date, RIGHTARG = text -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. +--! @param a eql_v3.query_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_date, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b eql_v3.query_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_date, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. +--! @param a eql_v3.query_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_date, RIGHTARG = jsonpath -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b eql_v3.query_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_date, RIGHTARG = jsonpath -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. +--! @param a eql_v3.query_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_date, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b eql_v3.query_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_date, RIGHTARG = text[] -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. +--! @param a eql_v3.query_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date, RIGHTARG = text -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. +--! @param a public.eql_v3_timestamp_ord_ore +--! @param b eql_v3.query_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date, RIGHTARG = integer -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. +--! @param a eql_v3.query_timestamp_ord_ore +--! @param b public.eql_v3_timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date, RIGHTARG = text[] -); +--! @file encrypted_domain/timestamp/query_timestamp_eq_operators.sql +--! @brief Operators for eql_v3.query_timestamp_eq. -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_date, RIGHTARG = text[] +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = eql_v3.query_timestamp_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_date, RIGHTARG = jsonb +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = eql_v3.query_timestamp_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/date/date_eq_operators.sql ---! @brief Operators for public.eql_v3_date_eq. +--! @file encrypted_domain/timestamp/timestamp_eq_operators.sql +--! @brief Operators for public.eql_v3_timestamp_eq. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq, + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq, + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb, + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/boolean/boolean_operators.sql ---! @brief Operators for public.eql_v3_boolean. - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_boolean, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_boolean, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_boolean, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_boolean, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_boolean, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_boolean, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq ); -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_boolean, RIGHTARG = text[] +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb ); -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonpath +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_boolean, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_boolean, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_boolean, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_boolean, RIGHTARG = integer + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_boolean, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_boolean, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/bigint/query_bigint_ord_ore_operators.sql ---! @brief Operators for eql_v3.query_bigint_ord_ore. +--! @file encrypted_domain/timestamp/query_timestamp_ord_ope_functions.sql +--! @brief Functions for eql_v3.query_timestamp_ord_ope. + +--! @brief Index extractor for eql_v3.query_timestamp_ord_ope. +--! @param a eql_v3.query_timestamp_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_timestamp_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b eql_v3.query_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. +--! @param a eql_v3.query_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b eql_v3.query_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. +--! @param a eql_v3.query_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b eql_v3.query_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. +--! @param a eql_v3.query_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b eql_v3.query_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. +--! @param a eql_v3.query_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b eql_v3.query_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. +--! @param a eql_v3.query_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. +--! @param a public.eql_v3_timestamp_ord_ope +--! @param b eql_v3.query_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. +--! @param a eql_v3.query_timestamp_ord_ope +--! @param b public.eql_v3_timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @file encrypted_domain/timestamp/timestamp_ord_ope_aggregates.sql +--! @brief Aggregates for public.eql_v3_timestamp_ord_ope. -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief State function for min on public.eql_v3_timestamp_ord_ope. +--! @param state public.eql_v3_timestamp_ord_ope +--! @param value public.eql_v3_timestamp_ord_ope +--! @return public.eql_v3_timestamp_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord_ope, value public.eql_v3_timestamp_ord_ope) +RETURNS public.eql_v3_timestamp_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +--! @brief min aggregate for public.eql_v3_timestamp_ord_ope. +--! @param input public.eql_v3_timestamp_ord_ope +--! @return public.eql_v3_timestamp_ord_ope +CREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.eql_v3_timestamp_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe ); -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief State function for max on public.eql_v3_timestamp_ord_ope. +--! @param state public.eql_v3_timestamp_ord_ope +--! @param value public.eql_v3_timestamp_ord_ope +--! @return public.eql_v3_timestamp_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord_ope, value public.eql_v3_timestamp_ord_ope) +RETURNS public.eql_v3_timestamp_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +--! @brief max aggregate for public.eql_v3_timestamp_ord_ope. +--! @param input public.eql_v3_timestamp_ord_ope +--! @return public.eql_v3_timestamp_ord_ope +CREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.eql_v3_timestamp_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/bigint/query_bigint_ord_operators.sql ---! @brief Operators for eql_v3.query_bigint_ord. +--! @file encrypted_domain/timestamp/query_timestamp_ord_functions.sql +--! @brief Functions for eql_v3.query_timestamp_ord. -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Index extractor for eql_v3.query_timestamp_ord. +--! @param a eql_v3.query_timestamp_ord +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_timestamp_ord) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b eql_v3.query_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord. +--! @param a eql_v3.query_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b eql_v3.query_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord. +--! @param a eql_v3.query_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; -CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, - COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b eql_v3.query_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord. +--! @param a eql_v3.query_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; -CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, - COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b eql_v3.query_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord. +--! @param a eql_v3.query_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; -CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, - COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b eql_v3.query_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord. +--! @param a eql_v3.query_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; -CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, - COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel -); +--! @brief Operator wrapper for eql_v3.query_timestamp_ord. +--! @param a public.eql_v3_timestamp_ord +--! @param b eql_v3.query_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.query_timestamp_ord. +--! @param a eql_v3.query_timestamp_ord +--! @param b public.eql_v3_timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/bigint/query_bigint_ord_ope_operators.sql ---! @brief Operators for eql_v3.query_bigint_ord_ope. +--! @file encrypted_domain/timestamp/query_timestamp_ord_ore_operators.sql +--! @brief Operators for eql_v3.query_timestamp_ord_ore. CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope, + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/bigint/query_bigint_eq_operators.sql ---! @brief Operators for eql_v3.query_bigint_eq. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = eql_v3.query_bigint_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = eql_v3.query_bigint_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_ord_ore_aggregates.sql ---! @brief Aggregates for public.eql_v3_bigint_ord_ore. - ---! @brief State function for min on public.eql_v3_bigint_ord_ore. ---! @param state public.eql_v3_bigint_ord_ore ---! @param value public.eql_v3_bigint_ord_ore ---! @return public.eql_v3_bigint_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord_ore, value public.eql_v3_bigint_ord_ore) -RETURNS public.eql_v3_bigint_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for public.eql_v3_bigint_ord_ore. ---! @param input public.eql_v3_bigint_ord_ore ---! @return public.eql_v3_bigint_ord_ore -CREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_bigint_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on public.eql_v3_bigint_ord_ore. ---! @param state public.eql_v3_bigint_ord_ore ---! @param value public.eql_v3_bigint_ord_ore ---! @return public.eql_v3_bigint_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord_ore, value public.eql_v3_bigint_ord_ore) -RETURNS public.eql_v3_bigint_ord_ore -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for public.eql_v3_bigint_ord_ore. ---! @param input public.eql_v3_bigint_ord_ore ---! @return public.eql_v3_bigint_ord_ore -CREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_bigint_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_ord_ope_aggregates.sql ---! @brief Aggregates for public.eql_v3_bigint_ord_ope. - ---! @brief State function for min on public.eql_v3_bigint_ord_ope. ---! @param state public.eql_v3_bigint_ord_ope ---! @param value public.eql_v3_bigint_ord_ope ---! @return public.eql_v3_bigint_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord_ope, value public.eql_v3_bigint_ord_ope) -RETURNS public.eql_v3_bigint_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value < state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate for public.eql_v3_bigint_ord_ope. ---! @param input public.eql_v3_bigint_ord_ope ---! @return public.eql_v3_bigint_ord_ope -CREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_bigint_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, - parallel = safe -); - ---! @brief State function for max on public.eql_v3_bigint_ord_ope. ---! @param state public.eql_v3_bigint_ord_ope ---! @param value public.eql_v3_bigint_ord_ope ---! @return public.eql_v3_bigint_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord_ope, value public.eql_v3_bigint_ord_ope) -RETURNS public.eql_v3_bigint_ord_ope -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -BEGIN - IF value > state THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate for public.eql_v3_bigint_ord_ope. ---! @param input public.eql_v3_bigint_ord_ope ---! @return public.eql_v3_bigint_ord_ope -CREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_bigint_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, - parallel = safe -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_ord_aggregates.sql ---! @brief Aggregates for public.eql_v3_bigint_ord. - ---! @brief State function for min on public.eql_v3_bigint_ord. ---! @param state public.eql_v3_bigint_ord ---! @param value public.eql_v3_bigint_ord ---! @return public.eql_v3_bigint_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord, value public.eql_v3_bigint_ord) -RETURNS public.eql_v3_bigint_ord +--! @file encrypted_domain/timestamp/timestamp_ord_ore_aggregates.sql +--! @brief Aggregates for public.eql_v3_timestamp_ord_ore. + +--! @brief State function for min on public.eql_v3_timestamp_ord_ore. +--! @param state public.eql_v3_timestamp_ord_ore +--! @param value public.eql_v3_timestamp_ord_ore +--! @return public.eql_v3_timestamp_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord_ore, value public.eql_v3_timestamp_ord_ore) +RETURNS public.eql_v3_timestamp_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -42040,22 +45175,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_bigint_ord. ---! @param input public.eql_v3_bigint_ord ---! @return public.eql_v3_bigint_ord -CREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord) ( +--! @brief min aggregate for public.eql_v3_timestamp_ord_ore. +--! @param input public.eql_v3_timestamp_ord_ore +--! @return public.eql_v3_timestamp_ord_ore +CREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord_ore) ( sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_bigint_ord, + stype = public.eql_v3_timestamp_ord_ore, combinefunc = eql_v3_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_bigint_ord. ---! @param state public.eql_v3_bigint_ord ---! @param value public.eql_v3_bigint_ord ---! @return public.eql_v3_bigint_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord, value public.eql_v3_bigint_ord) -RETURNS public.eql_v3_bigint_ord +--! @brief State function for max on public.eql_v3_timestamp_ord_ore. +--! @param state public.eql_v3_timestamp_ord_ore +--! @param value public.eql_v3_timestamp_ord_ore +--! @return public.eql_v3_timestamp_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord_ore, value public.eql_v3_timestamp_ord_ore) +RETURNS public.eql_v3_timestamp_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -42067,872 +45202,523 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_bigint_ord. ---! @param input public.eql_v3_bigint_ord ---! @return public.eql_v3_bigint_ord -CREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord) ( +--! @brief max aggregate for public.eql_v3_timestamp_ord_ore. +--! @param input public.eql_v3_timestamp_ord_ore +--! @return public.eql_v3_timestamp_ord_ore +CREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord_ore) ( sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_bigint_ord, + stype = public.eql_v3_timestamp_ord_ore, combinefunc = eql_v3_internal.max_sfunc, parallel = safe ); -- AUTOMATICALLY GENERATED FILE. ---! @file encrypted_domain/bigint/bigint_operators.sql ---! @brief Operators for public.eql_v3_bigint. +--! @file encrypted_domain/timestamp/timestamp_operators.sql +--! @brief Operators for public.eql_v3_timestamp. CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint + LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint + LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint + LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint + LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint + LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint + LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint + LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint + LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_bigint, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp, RIGHTARG = text ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_bigint, RIGHTARG = integer + LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer ); CREATE OPERATOR -> ( FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_bigint, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp, RIGHTARG = text ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_bigint, RIGHTARG = integer + LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer ); CREATE OPERATOR ->> ( FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR ? ( FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_bigint, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp, RIGHTARG = text ); CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_bigint, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[] ); CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_bigint, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[] ); CREATE OPERATOR @? ( FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonpath -); - -CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_bigint, RIGHTARG = text[] -); - -CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_bigint, RIGHTARG = text[] -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint, RIGHTARG = text -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint, RIGHTARG = integer -); - -CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint, RIGHTARG = text[] -); - -CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_bigint, RIGHTARG = text[] -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb -); - -CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint -); --- AUTOMATICALLY GENERATED FILE. - ---! @file encrypted_domain/bigint/bigint_eq_operators.sql ---! @brief Operators for public.eql_v3_bigint_eq. - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq, - COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq, - COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer -); - -CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer -); - -CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq -); - -CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text -); - -CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp ); -CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[] +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb ); -CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonpath +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonpath + LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[] ); CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[] ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text + LEFTARG = public.eql_v3_timestamp, RIGHTARG = text ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer + LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer ); CREATE OPERATOR - ( FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[] ); CREATE OPERATOR #- ( FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[] + LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[] ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq + LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb + LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR || ( FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp ); +-- AUTOMATICALLY GENERATED FILE. ---! @brief EQL lint: detect non-inlinable operator implementation functions ---! ---! Returns one row per violation found in the installed `eql_v3` surface. The ---! Postgres planner can only inline a function during index matching when: ---! ---! * `LANGUAGE sql` (plpgsql / C / etc. cannot be inlined) ---! * `IMMUTABLE` or `STABLE` volatility (VOLATILE cannot be inlined into ---! index expressions) ---! * No `SET` clauses (e.g. `SET search_path = ...`) ---! * Not `SECURITY DEFINER` ---! * Single-statement SELECT body ---! ---! @note The single-statement SELECT body condition is **not yet checked** by ---! this lint. A `LANGUAGE sql` function with a multi-statement body, a CTE, ---! or any pre-SELECT statement will pass all four implemented checks while ---! remaining non-inlinable. Implementing the check requires walking `prosrc` ---! (or `pg_get_functiondef`); tracked as a follow-up. ---! ---! Operators on `eql_v3` types (the jsonb-backed encrypted-domain families and ---! the SEM index-term type `eql_v3_internal.ore_block_256`) whose ---! implementation functions fail any of these rules silently fall back to seq ---! scan when the documented functional indexes (`eql_v3.eq_term(col)`, ---! `eql_v3.ord_term(col)`) are in place. This lint surfaces every such case. ---! ---! Severity: ---! `error` — fixable, blocks index matching, ship-blocking. ---! `warning` — likely-fixable, may not block matching but signals intent. ---! `info` — observational; useful for review, not a defect on its own. ---! ---! Categories: ---! `inlinability_language` — implementation function isn't `LANGUAGE sql`. ---! `inlinability_volatility` — implementation function is VOLATILE. ---! `inlinability_set_clause` — implementation function has a `SET` clause. ---! `inlinability_secdef` — implementation function is `SECURITY DEFINER`. ---! `inlinability_transitive` — implementation function is itself inlinable ---! but its body invokes a non-inlinable function ---! (depth 1; the planner can't peek through ---! that boundary). ---! `blocker_language` — encrypted-domain blocker is not LANGUAGE ---! plpgsql. The planner can inline / elide a ---! LANGUAGE sql body when the result is ---! provably unused, silently bypassing the ---! RAISE that the blocker exists to perform. ---! `blocker_strict` — encrypted-domain blocker is STRICT. ---! PostgreSQL skips the body and returns NULL ---! on NULL arguments, silently bypassing the ---! RAISE. ---! `domain_over_domain` — an `eql_v3` encrypted domain is derived from ---! another encrypted domain rather than jsonb. ---! Operators resolve against the ultimate base ---! type, so the derived domain does not ---! inherit the base domain's blocker surface. ---! `domain_opclass` — an operator class is declared FOR TYPE on an ---! `eql_v3` encrypted domain. Opclasses on ---! domains bypass operator resolution; use a ---! functional index on the extractor instead. ---! `schema_placement` — a naked composite or enum TYPE lives in the ---! public `eql_v3` schema. Internal index-term ---! types (e.g. `ore_block_256_term`) belong in ---! `eql_v3_internal`; a composite/enum in ---! `eql_v3` clutters the Supabase Table Builder ---! type picker, which the schema split exists to ---! prevent. Move it to `eql_v3_internal`. ---! ---! @example ---! ``` ---! SELECT severity, category, object_name, message ---! FROM eql_v3.lints() ---! WHERE severity = 'error' ---! ORDER BY category, object_name; ---! ``` ---! ---! @return SETOF record (severity text, category text, object_name text, message text) -CREATE OR REPLACE FUNCTION eql_v3.lints() -RETURNS TABLE ( - severity text, - category text, - object_name text, - message text -) -LANGUAGE sql STABLE -AS $$ - WITH - -- User-column encrypted domains now live in public so application tables - -- survive EQL uninstall. Keep this separate from owned_schemas(): public is - -- not installer-owned, but its EQL jsonb-backed domains are still the domain - -- types whose blockers/operator surfaces the lint must understand. - encrypted_domain_types AS ( - SELECT - dt.oid AS typid - FROM pg_catalog.pg_type dt - JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace - JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype - JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace - WHERE dt.typtype = 'd' - AND bt.typname = 'jsonb' - AND bn.nspname = 'pg_catalog' - AND ( - dn.nspname = 'public' - OR dn.nspname = ANY(eql_v3_internal.owned_schemas()) - ) - ), +--! @file encrypted_domain/timestamp/query_timestamp_ord_operators.sql +--! @brief Operators for eql_v3.query_timestamp_ord. - -- All operators where at least one operand is an EQL-owned type or a public - -- encrypted domain. Limits the scope of the lint to the operator surface - -- customers actually hit via SQL (`col = val`, `col @> '...'` and friends). - eql_operators AS ( - SELECT - op.oid AS oprid, - op.oprname AS opname, - op.oprcode AS implfunc, - op.oprleft::regtype AS lhs, - op.oprright::regtype AS rhs, - op.oprcode::regprocedure AS impl_signature - FROM pg_operator op - WHERE EXISTS ( - SELECT 1 FROM pg_type t - WHERE t.oid IN (op.oprleft, op.oprright) - AND ( - t.typnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY(eql_v3_internal.owned_schemas())) - OR t.oid IN (SELECT typid FROM encrypted_domain_types) - ) - ) - ), +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - -- Cross-join with each operator's implementation function metadata. - -- One row per operator; columns describe the inlinability of the impl. - op_impl AS ( - SELECT - eo.opname, - eo.lhs, - eo.rhs, - eo.implfunc AS impl_oid, - eo.impl_signature::text AS impl_signature, - lang_l.lanname AS lang, - p.provolatile AS volatility, - p.proconfig AS config, - p.prosecdef AS secdef, - p.prosrc AS body - FROM eql_operators eo - JOIN pg_proc p ON p.oid = eo.implfunc - JOIN pg_language lang_l ON lang_l.oid = p.prolang - ), +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - -- Encrypted-domain blockers: functions in `eql_v3` whose body contains - -- a blocker marker emitted by the codegen (any of the - -- `encrypted_domain_unsupported_*` helper calls — `_bool` for boolean - -- blockers, `_jsonb` for the native-jsonb-operator blockers; plus the - -- literal `is not supported for` for older path-operator blockers) AND - -- that take at least one encrypted domain over jsonb argument. The argument - -- filter excludes the shared `encrypted_domain_unsupported_*(text, text)` - -- helpers themselves, which contain the marker in their body but are not - -- blockers (they take text arguments, not a domain). - encrypted_domain_blockers AS ( - SELECT - p.oid AS oid, - p.oid::regprocedure::text AS signature, - lang_l.lanname AS lang, - p.proisstrict AS isstrict - FROM pg_catalog.pg_proc p - JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace - JOIN pg_catalog.pg_language lang_l ON lang_l.oid = p.prolang - WHERE n.nspname = ANY(eql_v3_internal.owned_schemas()) - AND (p.prosrc LIKE '%encrypted_domain_unsupported%' - OR p.prosrc LIKE '%is not supported for%') - AND EXISTS ( - SELECT 1 - FROM pg_catalog.unnest(p.proargtypes::oid[]) AS arg(typ) - JOIN encrypted_domain_types edt ON edt.typid = arg.typ - ) - ) +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); - -- ┌─────────────────────────────────────────────────────────────────┐ - -- │ Direct inlinability checks: each row examines one operator's │ - -- │ implementation function and emits a violation if any rule is │ - -- │ broken. Multiple violations on the same function become │ - -- │ multiple rows (developers see every reason it doesn't inline). │ - -- └─────────────────────────────────────────────────────────────────┘ +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); - SELECT - 'error' AS severity, - 'inlinability_language' AS category, - format('operator %s(%s, %s) -> %s', - opname, lhs, rhs, impl_signature) AS object_name, - format( - '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.', - lang, opname) AS message - FROM op_impl - WHERE lang <> 'sql' - AND NOT EXISTS ( - SELECT 1 FROM encrypted_domain_blockers b - WHERE b.oid = op_impl.impl_oid - ) +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); - UNION ALL +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); - SELECT - 'error', - 'inlinability_volatility', - format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature), - format( - '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).', - opname) - FROM op_impl - WHERE volatility = 'v' - AND NOT EXISTS ( - SELECT 1 FROM encrypted_domain_blockers b - WHERE b.oid = op_impl.impl_oid - ) +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); - UNION ALL +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); - SELECT - 'error', - 'inlinability_set_clause', - format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature), - format( - '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.') - FROM op_impl - WHERE config IS NOT NULL - AND NOT EXISTS ( - SELECT 1 FROM encrypted_domain_blockers b - WHERE b.oid = op_impl.impl_oid - ) +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); - UNION ALL +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); - SELECT - 'error', - 'inlinability_secdef', - format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature), - 'Operator implementation function is `SECURITY DEFINER`. Such functions cannot be inlined; remove `SECURITY DEFINER` or use a non-inlinable wrapper layer.' - FROM op_impl - WHERE secdef - AND NOT EXISTS ( - SELECT 1 FROM encrypted_domain_blockers b - WHERE b.oid = op_impl.impl_oid - ) +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); - -- ┌─────────────────────────────────────────────────────────────────┐ - -- │ Transitive inlinability: an operator implementation function │ - -- │ that's itself inlinable can still fail to inline if its body │ - -- │ calls a non-inlinable function. Walk one level via pg_depend. │ - -- │ │ - -- │ Postgres records function-to-function dependencies in │ - -- │ pg_depend with deptype 'n' (normal) when one function references│ - -- │ another in its body — but only at CREATE time and only for │ - -- │ direct calls. This is good enough for v1; deeper transitive │ - -- │ analysis is a follow-up. │ - -- └─────────────────────────────────────────────────────────────────┘ +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. - UNION ALL +--! @file encrypted_domain/timestamp/query_timestamp_ord_ope_operators.sql +--! @brief Operators for eql_v3.query_timestamp_ord_ope. - SELECT - 'error', - 'inlinability_transitive', - format('operator %s(%s, %s) -> %s', oi.opname, oi.lhs, oi.rhs, - oi.impl_signature), - format( - '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.', - called.proname, - called_lang.lanname, - CASE called.provolatile - WHEN 'i' THEN 'IMMUTABLE' - WHEN 's' THEN 'STABLE' - WHEN 'v' THEN 'VOLATILE' - END, - CASE WHEN called.proconfig IS NOT NULL - THEN ', has SET clause' - ELSE '' END) - FROM op_impl oi - -- Only worth the transitive check if the outer function is otherwise - -- inlinable — otherwise the direct lints above already report it. - JOIN pg_proc outer_p ON outer_p.oid = oi.impl_signature::regprocedure - JOIN pg_depend d - ON d.classid = 'pg_proc'::regclass - AND d.objid = outer_p.oid - AND d.refclassid = 'pg_proc'::regclass - AND d.deptype = 'n' - JOIN pg_proc called ON called.oid = d.refobjid - JOIN pg_language called_lang ON called_lang.oid = called.prolang - WHERE oi.lang = 'sql' - AND oi.volatility IN ('i', 's') - AND oi.config IS NULL - AND NOT oi.secdef - AND called.oid <> outer_p.oid - AND ( - called_lang.lanname <> 'sql' - OR called.provolatile = 'v' - OR called.proconfig IS NOT NULL - OR called.prosecdef - ) +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - -- ┌─────────────────────────────────────────────────────────────────┐ - -- │ Encrypted-domain footguns: blockers exist to RAISE, so they │ - -- │ have inverted inlinability requirements vs operator impls. │ - -- │ A LANGUAGE sql blocker can be elided by the planner; a STRICT │ - -- │ blocker returns NULL on NULL args. Both silently re-enable │ - -- │ operators the storage variant is supposed to block. │ - -- └─────────────────────────────────────────────────────────────────┘ +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); - UNION ALL +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); - SELECT - 'error', - 'blocker_language', - format('function %s', signature), - format( - '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.', - lang) - FROM encrypted_domain_blockers - WHERE lang <> 'plpgsql' +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); - UNION ALL +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); - SELECT - 'error', - 'blocker_strict', - format('function %s', signature), - 'Encrypted-domain blocker is `STRICT`. PostgreSQL skips the body and returns NULL on a NULL argument, silently bypassing the RAISE. Remove `STRICT`.' - FROM encrypted_domain_blockers - WHERE isstrict +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); - -- ┌─────────────────────────────────────────────────────────────────┐ - -- │ Domain identity: an encrypted-domain must be defined directly │ - -- │ over jsonb. Operators resolve against the ultimate base type, │ - -- │ so domain-over-domain inherits jsonb's operator surface and not │ - -- │ the base domain's blockers. │ - -- └─────────────────────────────────────────────────────────────────┘ +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); - UNION ALL +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); - SELECT - 'error', - 'domain_over_domain', - format('domain %I.%I', dn.nspname, dt.typname), - format( - '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.', - dn.nspname, dt.typname, bn.nspname, bt.typname) - FROM pg_catalog.pg_type dt - JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace - JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype - JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace - WHERE dt.typtype = 'd' - AND dn.nspname = ANY(eql_v3_internal.owned_schemas()) - AND bt.typtype = 'd' - AND bt.oid IN (SELECT typid FROM encrypted_domain_types) +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); - -- ┌─────────────────────────────────────────────────────────────────┐ - -- │ Domain opclass: an operator class declared FOR TYPE on an │ - -- │ encrypted-domain bypasses operator resolution at index time. │ - -- │ Use a functional index on the extractor instead. │ - -- └─────────────────────────────────────────────────────────────────┘ +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); - UNION ALL +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); - SELECT - 'error', - 'domain_opclass', - format('opclass %I.%I FOR TYPE %s.%s', cn.nspname, oc.opcname, tn.nspname, t.typname), - format( - '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.', - cn.nspname, oc.opcname, tn.nspname, t.typname, tn.nspname, tn.nspname) - FROM pg_catalog.pg_opclass oc - JOIN pg_catalog.pg_type t ON t.oid = oc.opcintype - JOIN pg_catalog.pg_namespace tn ON tn.oid = t.typnamespace - JOIN pg_catalog.pg_namespace cn ON cn.oid = oc.opcnamespace - WHERE t.oid IN (SELECT typid FROM encrypted_domain_types) +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); - -- ┌─────────────────────────────────────────────────────────────────┐ - -- │ Schema placement: the public `eql_v3` schema must hold only the │ - -- │ jsonb-backed encrypted-domain types. A naked composite/enum type │ - -- │ there is an internal index-term type in the wrong schema — it │ - -- │ clutters the Supabase type picker the split exists to keep clean. │ - -- └─────────────────────────────────────────────────────────────────┘ +--! @file v3/json/aggregates.sql +--! @brief min / max aggregates over public.eql_v3_json_entry. +--! +--! SteVec document entries extracted at a selector (`doc -> 'sel'`) order by +--! their CLLW OPE (`op`) term, so the extremum is picked by comparing +--! `eql_v3.ord_term(entry)` rather than the scalar Block-ORE `ord_term` the +--! generated scalar ord aggregates use. The ope_cllw bytea domain orders under +--! native byte comparison, so `<` / `>` on the extracted terms needs no custom +--! comparator. Same STRICT + PARALLEL SAFE shape as the generated scalar +--! `min`/`max` so partial/parallel aggregation is available on large GROUP BY +--! workloads. +--! +--! Per the encrypted-domain footgun rules the state functions are +--! `LANGUAGE plpgsql` with the pinned `search_path` — a `LANGUAGE sql` body would +--! be inlinable and the planner could elide it. +--! +--! @note **Only `op`-carrying entries are orderable.** `eql_v3.ord_term(entry)` +--! returns NULL when an entry has no `op` (CLLW OPE) term — the same entries a +--! `eql_v3.ord_term` btree NULL-filters from range scans. The state functions +--! therefore IGNORE `op`-less entries (they never become or survive as the +--! extremum), so `min`/`max` is well-defined over a mix of `op`-carrying and +--! `op`-less entries and is not corrupted by an `op`-less seed. A naive +--! `ord_term(value) < ord_term(state)` would be NULL whenever either side +--! lacks `op`, pinning a wrong (`op`-less) extremum when the first aggregated +--! row is `op`-less. An all-`op`-less input has no orderable extremum and +--! returns the (arbitrary) STRICT seed. - UNION ALL +--! @brief State function for min on public.eql_v3_json_entry. +--! +--! Keeps whichever orderable entry has the lesser CLLW OPE term. STRICT, so SQL +--! NULL entries are skipped by the aggregate machinery; `op`-less (non-orderable) +--! entries are skipped explicitly (see the @note on this file). +--! +--! @param state public.eql_v3_json_entry Running extremum. +--! @param value public.eql_v3_json_entry Candidate entry. +--! @return public.eql_v3_json_entry The lesser orderable entry by `ord_term`. +CREATE FUNCTION eql_v3_internal.jsonb_entry_min_sfunc( + state public.eql_v3_json_entry, + value public.eql_v3_json_entry +) +RETURNS public.eql_v3_json_entry +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +DECLARE + value_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(value); + state_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(state); +BEGIN + -- A non-orderable (op-less) candidate never replaces the running extremum. + IF value_ope IS NULL THEN + RETURN state; + END IF; + -- Adopt the candidate when the running extremum is itself non-orderable + -- (e.g. an op-less STRICT seed) or strictly greater. + IF state_ope IS NULL OR value_ope < state_ope THEN + RETURN value; + END IF; + RETURN state; +END; +$$; - SELECT - 'error', - 'schema_placement', - format('type %I.%I', n.nspname, t.typname), - format( - '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.nspname, t.typname, - CASE t.typtype WHEN 'c' THEN 'composite type' WHEN 'e' THEN 'enum type' ELSE 'type' END) - FROM pg_catalog.pg_type t - JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace - WHERE n.nspname = 'eql_v3' - AND t.typtype IN ('c', 'e') +--! @brief min aggregate over public.eql_v3_json_entry. +--! @param input public.eql_v3_json_entry +--! @return public.eql_v3_json_entry The entry with the smallest CLLW OPE term. +CREATE AGGREGATE eql_v3.min(public.eql_v3_json_entry) ( + sfunc = eql_v3_internal.jsonb_entry_min_sfunc, + stype = public.eql_v3_json_entry, + combinefunc = eql_v3_internal.jsonb_entry_min_sfunc, + parallel = safe +); - ORDER BY 1, 2, 3; +--! @brief State function for max on public.eql_v3_json_entry. +--! +--! Keeps whichever orderable entry has the greater CLLW OPE term. `op`-less +--! entries are skipped, mirroring `jsonb_entry_min_sfunc` (see the file @note). +--! +--! @param state public.eql_v3_json_entry Running extremum. +--! @param value public.eql_v3_json_entry Candidate entry. +--! @return public.eql_v3_json_entry The greater orderable entry by `ord_term`. +CREATE FUNCTION eql_v3_internal.jsonb_entry_max_sfunc( + state public.eql_v3_json_entry, + value public.eql_v3_json_entry +) +RETURNS public.eql_v3_json_entry +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +DECLARE + value_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(value); + state_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(state); +BEGIN + -- A non-orderable (op-less) candidate never replaces the running extremum. + IF value_ope IS NULL THEN + RETURN state; + END IF; + -- Adopt the candidate when the running extremum is itself non-orderable + -- (e.g. an op-less STRICT seed) or strictly lesser. + IF state_ope IS NULL OR value_ope > state_ope THEN + RETURN value; + END IF; + RETURN state; +END; $$; -COMMENT ON FUNCTION eql_v3.lints() IS - 'EQL lint: returns one row per non-inlinable operator implementation. ' - 'Run `SELECT * FROM eql_v3.lints() WHERE severity = ''error''` for a ' - 'CI-gateable check that all operator implementations on eql_v3 types are ' - 'eligible for planner inlining.'; +--! @brief max aggregate over public.eql_v3_json_entry. +--! @param input public.eql_v3_json_entry +--! @return public.eql_v3_json_entry The entry with the largest CLLW OPE term. +CREATE AGGREGATE eql_v3.max(public.eql_v3_json_entry) ( + sfunc = eql_v3_internal.jsonb_entry_max_sfunc, + stype = public.eql_v3_json_entry, + combinefunc = eql_v3_internal.jsonb_entry_max_sfunc, + parallel = safe +); ---! @file v3/jsonb/operators.sql ---! @brief Operators on public.eql_v3_json and public.eql_v3_jsonb_entry. +--! @file v3/json/operators.sql +--! @brief Operators on public.eql_v3_json_search and public.eql_v3_json_entry. ------------------------------------------------------------------------------ -- -> field accessor (returns jsonb_entry) @@ -42949,17 +45735,17 @@ COMMENT ON FUNCTION eql_v3.lints() IS --! parameter (`$1`, the Proxy interface) or an explicit cast (`col -> 'sel'::%text`). --! A bare untyped literal (`col -> 'sel'`) resolves to the NATIVE `jsonb -> %text` --! operator and silently returns native jsonb semantics (a root-key lookup, ---! typically NULL), NOT this operator: PostgreSQL reduces the `public.eql_v3_json` +--! typically NULL), NOT this operator: PostgreSQL reduces the `public.eql_v3_json_search` --! domain to its base type `jsonb` when resolving an unknown-typed RHS, and the --! native base-type operator wins the exact-match tiebreak. This is intrinsic to --! the domain type-kind and applies to the native-jsonb blockers too. See --! the "Typed operands" caveat in docs/reference/json-support.md. --! ---! @param e public.eql_v3_json Root encrypted payload. +--! @param e public.eql_v3_json_search Root encrypted payload. --! @param selector text Selector hash. ---! @return public.eql_v3_jsonb_entry Matching entry merged with root meta, or NULL. -CREATE FUNCTION eql_v3."->"(e public.eql_v3_json, selector text) - RETURNS public.eql_v3_jsonb_entry +--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL. +CREATE FUNCTION eql_v3."->"(e public.eql_v3_json_search, selector text) + RETURNS public.eql_v3_json_entry LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT ( @@ -42969,40 +45755,40 @@ AS $$ '$.sv[*] ? (@.s == $sel)'::jsonpath, jsonb_build_object('sel', selector) ) - )::public.eql_v3_jsonb_entry + )::public.eql_v3_json_entry $$; CREATE OPERATOR ->( FUNCTION=eql_v3."->", - LEFTARG=public.eql_v3_json, + LEFTARG=public.eql_v3_json_search, RIGHTARG=text ); --! @brief -> operator with integer array index (0-based, JSONB convention). ---! @param e public.eql_v3_json Encrypted sv-array payload. +--! @param e public.eql_v3_json_search Encrypted sv-array payload. --! @param selector integer Array index. ---! @return public.eql_v3_jsonb_entry Matching entry merged with root meta, or NULL. -CREATE FUNCTION eql_v3."->"(e public.eql_v3_json, selector integer) - RETURNS public.eql_v3_jsonb_entry +--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL. +CREATE FUNCTION eql_v3."->"(e public.eql_v3_json_search, selector integer) + RETURNS public.eql_v3_json_entry LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT CASE WHEN eql_v3_internal.is_ste_vec_array(e) THEN -- NOTE: `e::jsonb` makes the native-jsonb traversal explicit. `'sv'` is an - -- unknown-typed literal, so `e -> 'sv'` already flattens `public.eql_v3_json` to + -- unknown-typed literal, so `e -> 'sv'` already flattens `public.eql_v3_json_search` to -- its base type and binds native `jsonb -> text` (see the @warning above) — - -- the custom `->(public.eql_v3_json, text)` operator does NOT capture a bare + -- the custom `->(public.eql_v3_json_search, text)` operator does NOT capture a bare -- untyped literal. The cast documents that intent and guards the `-> selector` - -- (integer) hop from ever resolving to the v3 `->(public.eql_v3_json, integer)` + -- (integer) hop from ever resolving to the v3 `->(public.eql_v3_json_search, integer)` -- operator instead of native array access. - (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::public.eql_v3_jsonb_entry + (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::public.eql_v3_json_entry ELSE NULL END $$; CREATE OPERATOR ->( FUNCTION=eql_v3."->", - LEFTARG=public.eql_v3_json, + LEFTARG=public.eql_v3_json_search, RIGHTARG=integer ); @@ -43016,10 +45802,10 @@ CREATE OPERATOR ->( --! Intentional v2 parity: this serializes the entire matched jsonb_entry --! object as JSON text. It does not decrypt or return scalar plaintext like --! native `jsonb ->>`. ---! @param e public.eql_v3_json Encrypted payload. +--! @param e public.eql_v3_json_search Encrypted payload. --! @param selector text Field selector hash. --! @return text The matching entry as text. -CREATE FUNCTION eql_v3."->>"(e public.eql_v3_json, selector text) +CREATE FUNCTION eql_v3."->>"(e public.eql_v3_json_search, selector text) RETURNS text LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -43028,16 +45814,16 @@ $$; CREATE OPERATOR ->> ( FUNCTION=eql_v3."->>", - LEFTARG=public.eql_v3_json, + LEFTARG=public.eql_v3_json_search, RIGHTARG=text ); --! @brief ->> operator with integer array index. Inlinable alias of --! ->(json, integer) coerced to text. ---! @param e public.eql_v3_json Encrypted sv-array payload. +--! @param e public.eql_v3_json_search Encrypted sv-array payload. --! @param selector integer Array index. --! @return text The matching entry as text. -CREATE FUNCTION eql_v3."->>"(e public.eql_v3_json, selector integer) +CREATE FUNCTION eql_v3."->>"(e public.eql_v3_json_search, selector integer) RETURNS text LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -43046,7 +45832,7 @@ $$; CREATE OPERATOR ->> ( FUNCTION=eql_v3."->>", - LEFTARG=public.eql_v3_json, + LEFTARG=public.eql_v3_json_search, RIGHTARG=integer ); @@ -43055,11 +45841,11 @@ CREATE OPERATOR ->> ( ------------------------------------------------------------------------------ --! @brief @> contains operator (document, document). ---! @param a public.eql_v3_json Container. ---! @param b public.eql_v3_json Contained value. +--! @param a public.eql_v3_json_search Container. +--! @param b public.eql_v3_json_search Contained value. --! @return boolean True if a contains b. --! @see eql_v3.ste_vec_contains -CREATE FUNCTION eql_v3."@>"(a public.eql_v3_json, b public.eql_v3_json) +CREATE FUNCTION eql_v3."@>"(a public.eql_v3_json_search, b public.eql_v3_json_search) RETURNS boolean LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -43068,19 +45854,19 @@ $$; CREATE OPERATOR @>( FUNCTION=eql_v3."@>", - LEFTARG=public.eql_v3_json, - RIGHTARG=public.eql_v3_json + LEFTARG=public.eql_v3_json_search, + RIGHTARG=public.eql_v3_json_search ); ---! @brief @> contains operator with an query_jsonb needle. +--! @brief @> contains operator with an query_json needle. --! --! Inlines to native `jsonb @>` over `eql_v3.to_ste_vec_query(a)::jsonb`, so a --! functional GIN index on the same expression engages. --! ---! @param a public.eql_v3_json Container. ---! @param b eql_v3.query_jsonb Query payload. +--! @param a public.eql_v3_json_search Container. +--! @param b eql_v3.query_json Query payload. --! @return boolean True if a contains b. -CREATE FUNCTION eql_v3."@>"(a public.eql_v3_json, b eql_v3.query_jsonb) +CREATE FUNCTION eql_v3."@>"(a public.eql_v3_json_search, b eql_v3.query_json) RETURNS boolean LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -43089,8 +45875,8 @@ $$; CREATE OPERATOR @>( FUNCTION=eql_v3."@>", - LEFTARG=public.eql_v3_json, - RIGHTARG=eql_v3.query_jsonb + LEFTARG=public.eql_v3_json_search, + RIGHTARG=eql_v3.query_json ); --! @brief @> contains operator with a single jsonb_entry needle. @@ -43098,10 +45884,10 @@ CREATE OPERATOR @>( --! Wraps the entry into a single-element sv array (stripping `c`) and reduces --! to the same `to_ste_vec_query(a)::jsonb @> needle::jsonb` form. --! ---! @param a public.eql_v3_json Container. ---! @param b public.eql_v3_jsonb_entry Single entry. +--! @param a public.eql_v3_json_search Container. +--! @param b public.eql_v3_json_entry Single entry. --! @return boolean True if a contains an sv entry matching b. -CREATE FUNCTION eql_v3."@>"(a public.eql_v3_json, b public.eql_v3_jsonb_entry) +CREATE FUNCTION eql_v3."@>"(a public.eql_v3_json_search, b public.eql_v3_json_entry) RETURNS boolean LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -43122,8 +45908,8 @@ $$; CREATE OPERATOR @>( FUNCTION=eql_v3."@>", - LEFTARG=public.eql_v3_json, - RIGHTARG=public.eql_v3_jsonb_entry + LEFTARG=public.eql_v3_json_search, + RIGHTARG=public.eql_v3_json_entry ); ------------------------------------------------------------------------------ @@ -43131,10 +45917,10 @@ CREATE OPERATOR @>( ------------------------------------------------------------------------------ --! @brief <@ contained-by operator (document, document). ---! @param a public.eql_v3_json Contained value. ---! @param b public.eql_v3_json Container. +--! @param a public.eql_v3_json_search Contained value. +--! @param b public.eql_v3_json_search Container. --! @return boolean True if a is contained by b. -CREATE FUNCTION eql_v3."<@"(a public.eql_v3_json, b public.eql_v3_json) +CREATE FUNCTION eql_v3."<@"(a public.eql_v3_json_search, b public.eql_v3_json_search) RETURNS boolean LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -43143,15 +45929,15 @@ $$; CREATE OPERATOR <@( FUNCTION=eql_v3."<@", - LEFTARG=public.eql_v3_json, - RIGHTARG=public.eql_v3_json + LEFTARG=public.eql_v3_json_search, + RIGHTARG=public.eql_v3_json_search ); ---! @brief <@ contained-by operator with an query_jsonb LHS. ---! @param a eql_v3.query_jsonb Query payload. ---! @param b public.eql_v3_json Container. +--! @brief <@ contained-by operator with an query_json LHS. +--! @param a eql_v3.query_json Query payload. +--! @param b public.eql_v3_json_search Container. --! @return boolean True if b contains a. -CREATE FUNCTION eql_v3."<@"(a eql_v3.query_jsonb, b public.eql_v3_json) +CREATE FUNCTION eql_v3."<@"(a eql_v3.query_json, b public.eql_v3_json_search) RETURNS boolean LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -43160,15 +45946,15 @@ $$; CREATE OPERATOR <@( FUNCTION=eql_v3."<@", - LEFTARG=eql_v3.query_jsonb, - RIGHTARG=public.eql_v3_json + LEFTARG=eql_v3.query_json, + RIGHTARG=public.eql_v3_json_search ); --! @brief <@ contained-by operator with a jsonb_entry LHS. ---! @param a public.eql_v3_jsonb_entry Single entry. ---! @param b public.eql_v3_json Container. +--! @param a public.eql_v3_json_entry Single entry. +--! @param b public.eql_v3_json_search Container. --! @return boolean True if b contains a. -CREATE FUNCTION eql_v3."<@"(a public.eql_v3_jsonb_entry, b public.eql_v3_json) +CREATE FUNCTION eql_v3."<@"(a public.eql_v3_json_entry, b public.eql_v3_json_search) RETURNS boolean LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -43177,8 +45963,8 @@ $$; CREATE OPERATOR <@( FUNCTION=eql_v3."<@", - LEFTARG=public.eql_v3_jsonb_entry, - RIGHTARG=public.eql_v3_json + LEFTARG=public.eql_v3_json_entry, + RIGHTARG=public.eql_v3_json_search ); ------------------------------------------------------------------------------ @@ -43186,10 +45972,10 @@ CREATE OPERATOR <@( ------------------------------------------------------------------------------ --! @brief Equality on jsonb_entry via eq_term (hm-or-op byte equality). ---! @param a public.eql_v3_jsonb_entry Left operand ---! @param b public.eql_v3_jsonb_entry Right operand +--! @param a public.eql_v3_json_entry Left operand +--! @param b public.eql_v3_json_entry Right operand --! @return boolean True if the entries are equal -CREATE FUNCTION eql_v3.eq(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry) +CREATE FUNCTION eql_v3.eq(a public.eql_v3_json_entry, b public.eql_v3_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -43198,8 +45984,8 @@ $$; CREATE OPERATOR = ( FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_jsonb_entry, - RIGHTARG = public.eql_v3_jsonb_entry, + LEFTARG = public.eql_v3_json_entry, + RIGHTARG = public.eql_v3_json_entry, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, @@ -43207,10 +45993,10 @@ CREATE OPERATOR = ( ); --! @brief Inequality on jsonb_entry via eq_term. ---! @param a public.eql_v3_jsonb_entry Left operand ---! @param b public.eql_v3_jsonb_entry Right operand +--! @param a public.eql_v3_json_entry Left operand +--! @param b public.eql_v3_json_entry Right operand --! @return boolean True if the entries are not equal -CREATE FUNCTION eql_v3.neq(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry) +CREATE FUNCTION eql_v3.neq(a public.eql_v3_json_entry, b public.eql_v3_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -43219,8 +46005,8 @@ $$; CREATE OPERATOR <> ( FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_jsonb_entry, - RIGHTARG = public.eql_v3_jsonb_entry, + LEFTARG = public.eql_v3_json_entry, + RIGHTARG = public.eql_v3_json_entry, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, @@ -43228,10 +46014,10 @@ CREATE OPERATOR <> ( ); --! @brief Less-than on jsonb_entry via the CLLW OPE term (native bytea order). ---! @param a public.eql_v3_jsonb_entry Left operand ---! @param b public.eql_v3_jsonb_entry Right operand +--! @param a public.eql_v3_json_entry Left operand +--! @param b public.eql_v3_json_entry Right operand --! @return boolean True if a is less than b -CREATE FUNCTION eql_v3.lt(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry) +CREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b public.eql_v3_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -43240,8 +46026,8 @@ $$; CREATE OPERATOR < ( FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_jsonb_entry, - RIGHTARG = public.eql_v3_jsonb_entry, + LEFTARG = public.eql_v3_json_entry, + RIGHTARG = public.eql_v3_json_entry, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, @@ -43249,10 +46035,10 @@ CREATE OPERATOR < ( ); --! @brief Less-than-or-equal on jsonb_entry via the CLLW OPE term. ---! @param a public.eql_v3_jsonb_entry Left operand ---! @param b public.eql_v3_jsonb_entry Right operand +--! @param a public.eql_v3_json_entry Left operand +--! @param b public.eql_v3_json_entry Right operand --! @return boolean True if a is less than or equal to b -CREATE FUNCTION eql_v3.lte(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry) +CREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b public.eql_v3_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -43261,8 +46047,8 @@ $$; CREATE OPERATOR <= ( FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_jsonb_entry, - RIGHTARG = public.eql_v3_jsonb_entry, + LEFTARG = public.eql_v3_json_entry, + RIGHTARG = public.eql_v3_json_entry, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, @@ -43270,10 +46056,10 @@ CREATE OPERATOR <= ( ); --! @brief Greater-than on jsonb_entry via the CLLW OPE term. ---! @param a public.eql_v3_jsonb_entry Left operand ---! @param b public.eql_v3_jsonb_entry Right operand +--! @param a public.eql_v3_json_entry Left operand +--! @param b public.eql_v3_json_entry Right operand --! @return boolean True if a is greater than b -CREATE FUNCTION eql_v3.gt(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry) +CREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b public.eql_v3_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -43282,8 +46068,8 @@ $$; CREATE OPERATOR > ( FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_jsonb_entry, - RIGHTARG = public.eql_v3_jsonb_entry, + LEFTARG = public.eql_v3_json_entry, + RIGHTARG = public.eql_v3_json_entry, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, @@ -43291,10 +46077,10 @@ CREATE OPERATOR > ( ); --! @brief Greater-than-or-equal on jsonb_entry via the CLLW OPE term. ---! @param a public.eql_v3_jsonb_entry Left operand ---! @param b public.eql_v3_jsonb_entry Right operand +--! @param a public.eql_v3_json_entry Left operand +--! @param b public.eql_v3_json_entry Right operand --! @return boolean True if a is greater than or equal to b -CREATE FUNCTION eql_v3.gte(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry) +CREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b public.eql_v3_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -43303,19 +46089,19 @@ $$; CREATE OPERATOR >= ( FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_jsonb_entry, - RIGHTARG = public.eql_v3_jsonb_entry, + LEFTARG = public.eql_v3_json_entry, + RIGHTARG = public.eql_v3_json_entry, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); ---! @file v3/jsonb/blockers.sql ---! @brief Native-jsonb firewall for public.eql_v3_json. +--! @file v3/json/blockers.sql +--! @brief Native-jsonb firewall for public.eql_v3_json_search. --! ---! public.eql_v3_json SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons ---! = <> < <= > >= are supported on public.eql_v3_jsonb_entry only, not on the root +--! public.eql_v3_json_search SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons +--! = <> < <= > >= are supported on public.eql_v3_json_entry only, not on the root --! document domain. --! Every OTHER native jsonb operator reachable via domain fallback against the --! base type jsonb is BLOCKED here so an encrypted column can never silently @@ -43333,417 +46119,417 @@ CREATE OPERATOR >= ( --! so the firewall fires. --! @brief Blocker: ? (key/element exists). ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b text Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists(a public.eql_v3_json, b text) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists(a public.eql_v3_json_search, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '?'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR ? ( FUNCTION = eql_v3_internal.jsonb_blocked_exists, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = text ); --! @brief Blocker: ?| (any key exists). ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b text[] Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_any(a public.eql_v3_json, b text[]) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_any(a public.eql_v3_json_search, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '?|'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?|'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR ?| ( FUNCTION = eql_v3_internal.jsonb_blocked_exists_any, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = text[] ); --! @brief Blocker: ?& (all keys exist). ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b text[] Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_all(a public.eql_v3_json, b text[]) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_all(a public.eql_v3_json_search, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '?&'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?&'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR ?& ( FUNCTION = eql_v3_internal.jsonb_blocked_exists_all, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = text[] ); --! @brief Blocker: @? (jsonpath exists). ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b jsonpath Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_exists(a public.eql_v3_json, b jsonpath) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_exists(a public.eql_v3_json_search, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '@?'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@?'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR @? ( FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_exists, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = jsonpath ); --! @brief Blocker: @@ (jsonpath predicate). ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b jsonpath Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_match(a public.eql_v3_json, b jsonpath) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_match(a public.eql_v3_json_search, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '@@'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@@'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_match, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = jsonpath ); --! @brief Blocker: #> (path extract, native returns jsonb). ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b text[] Native RHS operand. --! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract(a public.eql_v3_json, b text[]) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract(a public.eql_v3_json_search, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '#>'); + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '#>'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR #> ( FUNCTION = eql_v3_internal.jsonb_blocked_path_extract, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = text[] ); --! @brief Blocker: #>> (path extract as text). ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b text[] Native RHS operand. --! @return text Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract_text(a public.eql_v3_json, b text[]) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract_text(a public.eql_v3_json_search, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_text('public.eql_v3_json', '#>>'); + RETURN eql_v3_internal.encrypted_domain_unsupported_text('public.eql_v3_json_search', '#>>'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR #>> ( FUNCTION = eql_v3_internal.jsonb_blocked_path_extract_text, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = text[] ); --! @brief Blocker: - (delete key, text RHS; native returns jsonb). ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b text Native RHS operand. --! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_text(a public.eql_v3_json, b text) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_text(a public.eql_v3_json_search, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '-'); + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR - ( FUNCTION = eql_v3_internal.jsonb_blocked_delete_text, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = text ); --! @brief Blocker: - (delete index, integer RHS). ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b integer Native RHS operand. --! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_int(a public.eql_v3_json, b integer) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_int(a public.eql_v3_json_search, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '-'); + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR - ( FUNCTION = eql_v3_internal.jsonb_blocked_delete_int, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = integer ); --! @brief Blocker: - (delete keys, text[] RHS). ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b text[] Native RHS operand. --! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_array(a public.eql_v3_json, b text[]) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_array(a public.eql_v3_json_search, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '-'); + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR - ( FUNCTION = eql_v3_internal.jsonb_blocked_delete_array, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = text[] ); --! @brief Blocker: #- (delete at path). ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b text[] Native RHS operand. --! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_path(a public.eql_v3_json, b text[]) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_path(a public.eql_v3_json_search, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '#-'); + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '#-'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR #- ( FUNCTION = eql_v3_internal.jsonb_blocked_delete_path, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = text[] ); --! @brief Blocker: || (concatenate, encrypted on the left). ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b jsonb Native RHS operand. --! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_concat(a public.eql_v3_json, b jsonb) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_concat(a public.eql_v3_json_search, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '||'); + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '||'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR || ( FUNCTION = eql_v3_internal.jsonb_blocked_concat, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = jsonb ); --! @brief Blocker: || (concatenate, encrypted on the right). --! @param a jsonb Native LHS operand. ---! @param b public.eql_v3_json Right operand (encrypted payload). +--! @param b public.eql_v3_json_search Right operand (encrypted payload). --! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_concat_rhs(a jsonb, b public.eql_v3_json) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_concat_rhs(a jsonb, b public.eql_v3_json_search) RETURNS jsonb IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '||'); + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '||'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR || ( FUNCTION = eql_v3_internal.jsonb_blocked_concat_rhs, LEFTARG = jsonb, - RIGHTARG = public.eql_v3_json + RIGHTARG = public.eql_v3_json_search ); ------------------------------------------------------------------------------ -- Root-document comparison blockers. ------------------------------------------------------------------------------ ---! @brief Blocker: root public.eql_v3_json document comparisons. ---! @param a public.eql_v3_json Left operand (encrypted payload). ---! @param b public.eql_v3_json Right operand (encrypted payload). +--! @brief Blocker: root public.eql_v3_json_search document comparisons. +--! @param a public.eql_v3_json_search Left operand (encrypted payload). +--! @param b public.eql_v3_json_search Right operand (encrypted payload). --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_json(a public.eql_v3_json, b public.eql_v3_json) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_json(a public.eql_v3_json_search, b public.eql_v3_json_search) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', 'comparison'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison'); END; $$ LANGUAGE plpgsql; ---! @brief Blocker: root public.eql_v3_json-to-jsonb comparisons. ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @brief Blocker: root public.eql_v3_json_search-to-jsonb comparisons. +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b jsonb Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_jsonb(a public.eql_v3_json, b jsonb) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_jsonb(a public.eql_v3_json_search, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', 'comparison'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison'); END; $$ LANGUAGE plpgsql; ---! @brief Blocker: root jsonb-to-public.eql_v3_json comparisons. +--! @brief Blocker: root jsonb-to-public.eql_v3_json_search comparisons. --! @param a jsonb Native LHS operand. ---! @param b public.eql_v3_json Right operand (encrypted payload). +--! @param b public.eql_v3_json_search Right operand (encrypted payload). --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_jsonb_json(a jsonb, b public.eql_v3_json) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_jsonb_json(a jsonb, b public.eql_v3_json_search) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', 'comparison'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR = ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = public.eql_v3_json, - RIGHTARG = public.eql_v3_json + LEFTARG = public.eql_v3_json_search, + RIGHTARG = public.eql_v3_json_search ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = jsonb ); CREATE OPERATOR = ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, LEFTARG = jsonb, - RIGHTARG = public.eql_v3_json + RIGHTARG = public.eql_v3_json_search ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = public.eql_v3_json, - RIGHTARG = public.eql_v3_json + LEFTARG = public.eql_v3_json_search, + RIGHTARG = public.eql_v3_json_search ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = jsonb ); CREATE OPERATOR <> ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, LEFTARG = jsonb, - RIGHTARG = public.eql_v3_json + RIGHTARG = public.eql_v3_json_search ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = public.eql_v3_json, - RIGHTARG = public.eql_v3_json + LEFTARG = public.eql_v3_json_search, + RIGHTARG = public.eql_v3_json_search ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = jsonb ); CREATE OPERATOR < ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, LEFTARG = jsonb, - RIGHTARG = public.eql_v3_json + RIGHTARG = public.eql_v3_json_search ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = public.eql_v3_json, - RIGHTARG = public.eql_v3_json + LEFTARG = public.eql_v3_json_search, + RIGHTARG = public.eql_v3_json_search ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = jsonb ); CREATE OPERATOR <= ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, LEFTARG = jsonb, - RIGHTARG = public.eql_v3_json + RIGHTARG = public.eql_v3_json_search ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = public.eql_v3_json, - RIGHTARG = public.eql_v3_json + LEFTARG = public.eql_v3_json_search, + RIGHTARG = public.eql_v3_json_search ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = jsonb ); CREATE OPERATOR > ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, LEFTARG = jsonb, - RIGHTARG = public.eql_v3_json + RIGHTARG = public.eql_v3_json_search ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = public.eql_v3_json, - RIGHTARG = public.eql_v3_json + LEFTARG = public.eql_v3_json_search, + RIGHTARG = public.eql_v3_json_search ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = jsonb ); CREATE OPERATOR >= ( FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, LEFTARG = jsonb, - RIGHTARG = public.eql_v3_json + RIGHTARG = public.eql_v3_json_search ); ------------------------------------------------------------------------------ @@ -43751,197 +46537,83 @@ CREATE OPERATOR >= ( ------------------------------------------------------------------------------ --! @brief Blocker: @> with encrypted root document and native jsonb. ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b jsonb Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_json_jsonb(a public.eql_v3_json, b jsonb) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_json_jsonb(a public.eql_v3_json_search, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '@>'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@>'); END; $$ LANGUAGE plpgsql; --! @brief Blocker: @> with native jsonb and encrypted root document. --! @param a jsonb Native LHS operand. ---! @param b public.eql_v3_json Right operand (encrypted payload). +--! @param b public.eql_v3_json_search Right operand (encrypted payload). --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_jsonb_json(a jsonb, b public.eql_v3_json) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_jsonb_json(a jsonb, b public.eql_v3_json_search) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '@>'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@>'); END; $$ LANGUAGE plpgsql; --! @brief Blocker: <@ with encrypted root document and native jsonb. ---! @param a public.eql_v3_json Left operand (encrypted payload). +--! @param a public.eql_v3_json_search Left operand (encrypted payload). --! @param b jsonb Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_json_jsonb(a public.eql_v3_json, b jsonb) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_json_jsonb(a public.eql_v3_json_search, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '<@'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '<@'); END; $$ LANGUAGE plpgsql; --! @brief Blocker: <@ with native jsonb and encrypted root document. --! @param a jsonb Native LHS operand. ---! @param b public.eql_v3_json Right operand (encrypted payload). +--! @param b public.eql_v3_json_search Right operand (encrypted payload). --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_jsonb_json(a jsonb, b public.eql_v3_json) +CREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_jsonb_json(a jsonb, b public.eql_v3_json_search) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '<@'); + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '<@'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.jsonb_blocked_contains_json_jsonb, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = jsonb ); CREATE OPERATOR @> ( FUNCTION = eql_v3_internal.jsonb_blocked_contains_jsonb_json, LEFTARG = jsonb, - RIGHTARG = public.eql_v3_json + RIGHTARG = public.eql_v3_json_search ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.jsonb_blocked_contained_json_jsonb, - LEFTARG = public.eql_v3_json, + LEFTARG = public.eql_v3_json_search, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( FUNCTION = eql_v3_internal.jsonb_blocked_contained_jsonb_json, LEFTARG = jsonb, - RIGHTARG = public.eql_v3_json -); - ---! @file v3/jsonb/aggregates.sql ---! @brief min / max aggregates over public.eql_v3_jsonb_entry. ---! ---! SteVec document entries extracted at a selector (`doc -> 'sel'`) order by ---! their CLLW OPE (`op`) term, so the extremum is picked by comparing ---! `eql_v3.ord_term(entry)` rather than the scalar Block-ORE `ord_term` the ---! generated scalar ord aggregates use. The ope_cllw bytea domain orders under ---! native byte comparison, so `<` / `>` on the extracted terms needs no custom ---! comparator. Same STRICT + PARALLEL SAFE shape as the generated scalar ---! `min`/`max` so partial/parallel aggregation is available on large GROUP BY ---! workloads. ---! ---! Per the encrypted-domain footgun rules the state functions are ---! `LANGUAGE plpgsql` with the pinned `search_path` — a `LANGUAGE sql` body would ---! be inlinable and the planner could elide it. ---! ---! @note **Only `op`-carrying entries are orderable.** `eql_v3.ord_term(entry)` ---! returns NULL when an entry has no `op` (CLLW OPE) term — the same entries a ---! `eql_v3.ord_term` btree NULL-filters from range scans. The state functions ---! therefore IGNORE `op`-less entries (they never become or survive as the ---! extremum), so `min`/`max` is well-defined over a mix of `op`-carrying and ---! `op`-less entries and is not corrupted by an `op`-less seed. A naive ---! `ord_term(value) < ord_term(state)` would be NULL whenever either side ---! lacks `op`, pinning a wrong (`op`-less) extremum when the first aggregated ---! row is `op`-less. An all-`op`-less input has no orderable extremum and ---! returns the (arbitrary) STRICT seed. - ---! @brief State function for min on public.eql_v3_jsonb_entry. ---! ---! Keeps whichever orderable entry has the lesser CLLW OPE term. STRICT, so SQL ---! NULL entries are skipped by the aggregate machinery; `op`-less (non-orderable) ---! entries are skipped explicitly (see the @note on this file). ---! ---! @param state public.eql_v3_jsonb_entry Running extremum. ---! @param value public.eql_v3_jsonb_entry Candidate entry. ---! @return public.eql_v3_jsonb_entry The lesser orderable entry by `ord_term`. -CREATE FUNCTION eql_v3_internal.jsonb_entry_min_sfunc( - state public.eql_v3_jsonb_entry, - value public.eql_v3_jsonb_entry -) -RETURNS public.eql_v3_jsonb_entry -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -DECLARE - value_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(value); - state_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(state); -BEGIN - -- A non-orderable (op-less) candidate never replaces the running extremum. - IF value_ope IS NULL THEN - RETURN state; - END IF; - -- Adopt the candidate when the running extremum is itself non-orderable - -- (e.g. an op-less STRICT seed) or strictly greater. - IF state_ope IS NULL OR value_ope < state_ope THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief min aggregate over public.eql_v3_jsonb_entry. ---! @param input public.eql_v3_jsonb_entry ---! @return public.eql_v3_jsonb_entry The entry with the smallest CLLW OPE term. -CREATE AGGREGATE eql_v3.min(public.eql_v3_jsonb_entry) ( - sfunc = eql_v3_internal.jsonb_entry_min_sfunc, - stype = public.eql_v3_jsonb_entry, - combinefunc = eql_v3_internal.jsonb_entry_min_sfunc, - parallel = safe -); - ---! @brief State function for max on public.eql_v3_jsonb_entry. ---! ---! Keeps whichever orderable entry has the greater CLLW OPE term. `op`-less ---! entries are skipped, mirroring `jsonb_entry_min_sfunc` (see the file @note). ---! ---! @param state public.eql_v3_jsonb_entry Running extremum. ---! @param value public.eql_v3_jsonb_entry Candidate entry. ---! @return public.eql_v3_jsonb_entry The greater orderable entry by `ord_term`. -CREATE FUNCTION eql_v3_internal.jsonb_entry_max_sfunc( - state public.eql_v3_jsonb_entry, - value public.eql_v3_jsonb_entry -) -RETURNS public.eql_v3_jsonb_entry -LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE -SET search_path = pg_catalog, extensions, public -AS $$ -DECLARE - value_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(value); - state_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(state); -BEGIN - -- A non-orderable (op-less) candidate never replaces the running extremum. - IF value_ope IS NULL THEN - RETURN state; - END IF; - -- Adopt the candidate when the running extremum is itself non-orderable - -- (e.g. an op-less STRICT seed) or strictly lesser. - IF state_ope IS NULL OR value_ope > state_ope THEN - RETURN value; - END IF; - RETURN state; -END; -$$; - ---! @brief max aggregate over public.eql_v3_jsonb_entry. ---! @param input public.eql_v3_jsonb_entry ---! @return public.eql_v3_jsonb_entry The entry with the largest CLLW OPE term. -CREATE AGGREGATE eql_v3.max(public.eql_v3_jsonb_entry) ( - sfunc = eql_v3_internal.jsonb_entry_max_sfunc, - stype = public.eql_v3_jsonb_entry, - combinefunc = eql_v3_internal.jsonb_entry_max_sfunc, - parallel = safe + RIGHTARG = public.eql_v3_json_search ); --! @file pin_search_path_v3.sql --! @brief Post-install: pin search_path on every eql_v3.* function. diff --git a/packages/eql/sql/release-manifest.json b/packages/eql/sql/release-manifest.json index cf5e0e28d..b27c45e21 100644 --- a/packages/eql/sql/release-manifest.json +++ b/packages/eql/sql/release-manifest.json @@ -1,6 +1,6 @@ { "eqlVersion": "3.0.0", "schemaVersion": 3, - "installSqlSha256": "9311a0c9faeaebe1397fba2abf9e581ce006e94bbd0255596c21e5ada5245afa", + "installSqlSha256": "6da5ed462b02f53a0636d783880533496eecfb52218d718791085376bc44c6a0", "uninstallSqlSha256": "b1b5131b8175c5d04da9ada108d25c81c5772b15fad79a6c419ebb32d18c60a9" } diff --git a/packages/eql/src/generated/release-manifest.ts b/packages/eql/src/generated/release-manifest.ts index d9f0032f7..b6e81c7a0 100644 --- a/packages/eql/src/generated/release-manifest.ts +++ b/packages/eql/src/generated/release-manifest.ts @@ -1,6 +1,6 @@ export const releaseManifest = { eqlVersion: '3.0.0', schemaVersion: 3, - installSqlSha256: '9311a0c9faeaebe1397fba2abf9e581ce006e94bbd0255596c21e5ada5245afa', + installSqlSha256: '6da5ed462b02f53a0636d783880533496eecfb52218d718791085376bc44c6a0', uninstallSqlSha256: 'b1b5131b8175c5d04da9ada108d25c81c5772b15fad79a6c419ebb32d18c60a9', } as const diff --git a/packages/eql/src/generated/schema/v3/eql_v3_text_match.json b/packages/eql/src/generated/schema/v3/eql_v3_text_match.json index e3b30c709..ab09f364d 100644 --- a/packages/eql/src/generated/schema/v3/eql_v3_text_match.json +++ b/packages/eql/src/generated/schema/v3/eql_v3_text_match.json @@ -1,7 +1,7 @@ { "$defs": { "BloomFilter": { - "description": "Bloom-filter match term — the `bf` wire key. Backs the `_match` domains (`@>`/`<@` containment). Signed i16: EQL stores the filter as PostgreSQL `smallint[]`, and filters sized above 32768 emit upper-half bit positions as negative signed values.", + "description": "Bloom-filter match term — the `bf` wire key. Backs the fuzzy-match `@@` (`eql_v3.matches`) surface on the `_match` domains; the containment operators `@>`/`<@` survive only as internal blockers that raise (CIP-3517). Signed i16: EQL stores the filter as PostgreSQL `smallint[]`, and filters sized above 32768 emit upper-half bit positions as negative signed values.", "items": { "format": "int16", "maximum": 32767, @@ -42,7 +42,7 @@ "$id": "https://schemas.cipherstash.com/eql/v3/eql_v3_text_match.json", "$schema": "https://json-schema.org/draft/2020-12/schema", "additionalProperties": false, - "description": "`public.eql_v3_text_match` — match domain.\n\nOperators: `@>` `<@`. Required keys: `v` `i` `c` `bf`.", + "description": "`public.eql_v3_text_match` — match domain.\n\nOperators: `@@`. Required keys: `v` `i` `c` `bf`.", "properties": { "bf": { "$ref": "#/$defs/BloomFilter" diff --git a/packages/eql/src/generated/schema/v3/eql_v3_text_search.json b/packages/eql/src/generated/schema/v3/eql_v3_text_search.json index f4982fa46..759cc54af 100644 --- a/packages/eql/src/generated/schema/v3/eql_v3_text_search.json +++ b/packages/eql/src/generated/schema/v3/eql_v3_text_search.json @@ -1,7 +1,7 @@ { "$defs": { "BloomFilter": { - "description": "Bloom-filter match term — the `bf` wire key. Backs the `_match` domains (`@>`/`<@` containment). Signed i16: EQL stores the filter as PostgreSQL `smallint[]`, and filters sized above 32768 emit upper-half bit positions as negative signed values.", + "description": "Bloom-filter match term — the `bf` wire key. Backs the fuzzy-match `@@` (`eql_v3.matches`) surface on the `_match` domains; the containment operators `@>`/`<@` survive only as internal blockers that raise (CIP-3517). Signed i16: EQL stores the filter as PostgreSQL `smallint[]`, and filters sized above 32768 emit upper-half bit positions as negative signed values.", "items": { "format": "int16", "maximum": 32767, @@ -50,7 +50,7 @@ "$id": "https://schemas.cipherstash.com/eql/v3/eql_v3_text_search.json", "$schema": "https://json-schema.org/draft/2020-12/schema", "additionalProperties": false, - "description": "`public.eql_v3_text_search` — search domain.\n\nOperators: `=` `<>` `<` `<=` `>` `>=` `@>` `<@`. Required keys: `v` `i` `c` `hm` `op` `bf`.", + "description": "`public.eql_v3_text_search` — search domain.\n\nOperators: `=` `<>` `<` `<=` `>` `>=` `@@`. Required keys: `v` `i` `c` `hm` `op` `bf`.", "properties": { "bf": { "$ref": "#/$defs/BloomFilter" diff --git a/packages/eql/src/generated/schema/v3/eql_v3_text_search_ore.json b/packages/eql/src/generated/schema/v3/eql_v3_text_search_ore.json index c286e443e..d7fc56da6 100644 --- a/packages/eql/src/generated/schema/v3/eql_v3_text_search_ore.json +++ b/packages/eql/src/generated/schema/v3/eql_v3_text_search_ore.json @@ -1,7 +1,7 @@ { "$defs": { "BloomFilter": { - "description": "Bloom-filter match term — the `bf` wire key. Backs the `_match` domains (`@>`/`<@` containment). Signed i16: EQL stores the filter as PostgreSQL `smallint[]`, and filters sized above 32768 emit upper-half bit positions as negative signed values.", + "description": "Bloom-filter match term — the `bf` wire key. Backs the fuzzy-match `@@` (`eql_v3.matches`) surface on the `_match` domains; the containment operators `@>`/`<@` survive only as internal blockers that raise (CIP-3517). Signed i16: EQL stores the filter as PostgreSQL `smallint[]`, and filters sized above 32768 emit upper-half bit positions as negative signed values.", "items": { "format": "int16", "maximum": 32767, @@ -53,7 +53,7 @@ "$id": "https://schemas.cipherstash.com/eql/v3/eql_v3_text_search_ore.json", "$schema": "https://json-schema.org/draft/2020-12/schema", "additionalProperties": false, - "description": "`public.eql_v3_text_search_ore` — search domain.\n\nOperators: `=` `<>` `<` `<=` `>` `>=` `@>` `<@`. Required keys: `v` `i` `c` `hm` `ob` `bf`.", + "description": "`public.eql_v3_text_search_ore` — search domain.\n\nOperators: `=` `<>` `<` `<=` `>` `>=` `@@`. Required keys: `v` `i` `c` `hm` `ob` `bf`.", "properties": { "bf": { "$ref": "#/$defs/BloomFilter" diff --git a/packages/eql/src/generated/schema/v3/query_text_match.json b/packages/eql/src/generated/schema/v3/query_text_match.json index d7a781677..aa9f5a984 100644 --- a/packages/eql/src/generated/schema/v3/query_text_match.json +++ b/packages/eql/src/generated/schema/v3/query_text_match.json @@ -1,7 +1,7 @@ { "$defs": { "BloomFilter": { - "description": "Bloom-filter match term — the `bf` wire key. Backs the `_match` domains (`@>`/`<@` containment). Signed i16: EQL stores the filter as PostgreSQL `smallint[]`, and filters sized above 32768 emit upper-half bit positions as negative signed values.", + "description": "Bloom-filter match term — the `bf` wire key. Backs the fuzzy-match `@@` (`eql_v3.matches`) surface on the `_match` domains; the containment operators `@>`/`<@` survive only as internal blockers that raise (CIP-3517). Signed i16: EQL stores the filter as PostgreSQL `smallint[]`, and filters sized above 32768 emit upper-half bit positions as negative signed values.", "items": { "format": "int16", "maximum": 32767, @@ -38,7 +38,7 @@ "$id": "https://schemas.cipherstash.com/eql/v3/query_text_match.json", "$schema": "https://json-schema.org/draft/2020-12/schema", "additionalProperties": false, - "description": "`eql_v3.query_text_match` — match domain query operand.\n\nOperators: `@>` `<@`. Required keys: `v` `i` `bf`.", + "description": "`eql_v3.query_text_match` — match domain query operand.\n\nOperators: `@@`. Required keys: `v` `i` `bf`.", "properties": { "bf": { "$ref": "#/$defs/BloomFilter" diff --git a/packages/eql/src/generated/schema/v3/query_text_search.json b/packages/eql/src/generated/schema/v3/query_text_search.json index d2d9eff7b..6d955fa63 100644 --- a/packages/eql/src/generated/schema/v3/query_text_search.json +++ b/packages/eql/src/generated/schema/v3/query_text_search.json @@ -1,7 +1,7 @@ { "$defs": { "BloomFilter": { - "description": "Bloom-filter match term — the `bf` wire key. Backs the `_match` domains (`@>`/`<@` containment). Signed i16: EQL stores the filter as PostgreSQL `smallint[]`, and filters sized above 32768 emit upper-half bit positions as negative signed values.", + "description": "Bloom-filter match term — the `bf` wire key. Backs the fuzzy-match `@@` (`eql_v3.matches`) surface on the `_match` domains; the containment operators `@>`/`<@` survive only as internal blockers that raise (CIP-3517). Signed i16: EQL stores the filter as PostgreSQL `smallint[]`, and filters sized above 32768 emit upper-half bit positions as negative signed values.", "items": { "format": "int16", "maximum": 32767, @@ -46,7 +46,7 @@ "$id": "https://schemas.cipherstash.com/eql/v3/query_text_search.json", "$schema": "https://json-schema.org/draft/2020-12/schema", "additionalProperties": false, - "description": "`eql_v3.query_text_search` — search domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=` `@>` `<@`. Required keys: `v` `i` `hm` `op` `bf`.", + "description": "`eql_v3.query_text_search` — search domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=` `@@`. Required keys: `v` `i` `hm` `op` `bf`.", "properties": { "bf": { "$ref": "#/$defs/BloomFilter" diff --git a/packages/eql/src/generated/schema/v3/query_text_search_ore.json b/packages/eql/src/generated/schema/v3/query_text_search_ore.json index 1b3620062..01fca8aa9 100644 --- a/packages/eql/src/generated/schema/v3/query_text_search_ore.json +++ b/packages/eql/src/generated/schema/v3/query_text_search_ore.json @@ -1,7 +1,7 @@ { "$defs": { "BloomFilter": { - "description": "Bloom-filter match term — the `bf` wire key. Backs the `_match` domains (`@>`/`<@` containment). Signed i16: EQL stores the filter as PostgreSQL `smallint[]`, and filters sized above 32768 emit upper-half bit positions as negative signed values.", + "description": "Bloom-filter match term — the `bf` wire key. Backs the fuzzy-match `@@` (`eql_v3.matches`) surface on the `_match` domains; the containment operators `@>`/`<@` survive only as internal blockers that raise (CIP-3517). Signed i16: EQL stores the filter as PostgreSQL `smallint[]`, and filters sized above 32768 emit upper-half bit positions as negative signed values.", "items": { "format": "int16", "maximum": 32767, @@ -49,7 +49,7 @@ "$id": "https://schemas.cipherstash.com/eql/v3/query_text_search_ore.json", "$schema": "https://json-schema.org/draft/2020-12/schema", "additionalProperties": false, - "description": "`eql_v3.query_text_search_ore` — search domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=` `@>` `<@`. Required keys: `v` `i` `hm` `ob` `bf`.", + "description": "`eql_v3.query_text_search_ore` — search domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=` `@@`. Required keys: `v` `i` `hm` `ob` `bf`.", "properties": { "bf": { "$ref": "#/$defs/BloomFilter" diff --git a/packages/eql/src/generated/v3/BloomFilter.ts b/packages/eql/src/generated/v3/BloomFilter.ts index 6861ce1c5..a64241cf5 100644 --- a/packages/eql/src/generated/v3/BloomFilter.ts +++ b/packages/eql/src/generated/v3/BloomFilter.ts @@ -1,8 +1,9 @@ // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually. /** - * Bloom-filter match term — the `bf` wire key. Backs the `_match` domains - * (`@>`/`<@` containment). + * Bloom-filter match term — the `bf` wire key. Backs the fuzzy-match `@@` + * (`eql_v3.matches`) surface on the `_match` domains; the containment operators + * `@>`/`<@` survive only as internal blockers that raise (CIP-3517). * * **Signed** i16, not u16: EQL stores the filter as PostgreSQL `smallint[]`, * and filters sized above 32768 emit upper-half bit positions as negative diff --git a/packages/eql/src/generated/v3/TextMatch.ts b/packages/eql/src/generated/v3/TextMatch.ts index eef14fe15..b47956a03 100644 --- a/packages/eql/src/generated/v3/TextMatch.ts +++ b/packages/eql/src/generated/v3/TextMatch.ts @@ -7,6 +7,6 @@ import type { SchemaVersion } from "./SchemaVersion"; /** * `public.eql_v3_text_match` — match domain. * - * Operators: `@>` `<@`. Required keys: `v` `i` `c` `bf`. + * Operators: `@@`. Required keys: `v` `i` `c` `bf`. */ export type TextMatch = { v: SchemaVersion, i: Identifier, c: Ciphertext, bf: BloomFilter, }; diff --git a/packages/eql/src/generated/v3/TextMatchQuery.ts b/packages/eql/src/generated/v3/TextMatchQuery.ts index 4e525ab6c..ce5a38700 100644 --- a/packages/eql/src/generated/v3/TextMatchQuery.ts +++ b/packages/eql/src/generated/v3/TextMatchQuery.ts @@ -6,6 +6,6 @@ import type { SchemaVersion } from "./SchemaVersion"; /** * `eql_v3.query_text_match` — match domain query operand. * - * Operators: `@>` `<@`. Required keys: `v` `i` `bf`. + * Operators: `@@`. Required keys: `v` `i` `bf`. */ export type TextMatchQuery = { v: SchemaVersion, i: Identifier, bf: BloomFilter, }; diff --git a/packages/eql/src/generated/v3/TextSearch.ts b/packages/eql/src/generated/v3/TextSearch.ts index 02a81011f..771315115 100644 --- a/packages/eql/src/generated/v3/TextSearch.ts +++ b/packages/eql/src/generated/v3/TextSearch.ts @@ -9,6 +9,6 @@ import type { SchemaVersion } from "./SchemaVersion"; /** * `public.eql_v3_text_search` — search domain. * - * Operators: `=` `<>` `<` `<=` `>` `>=` `@>` `<@`. Required keys: `v` `i` `c` `hm` `op` `bf`. + * Operators: `=` `<>` `<` `<=` `>` `>=` `@@`. Required keys: `v` `i` `c` `hm` `op` `bf`. */ export type TextSearch = { v: SchemaVersion, i: Identifier, c: Ciphertext, hm: Hmac256, op: OpeCllw, bf: BloomFilter, }; diff --git a/packages/eql/src/generated/v3/TextSearchOre.ts b/packages/eql/src/generated/v3/TextSearchOre.ts index 82a910cf4..47761ee95 100644 --- a/packages/eql/src/generated/v3/TextSearchOre.ts +++ b/packages/eql/src/generated/v3/TextSearchOre.ts @@ -9,6 +9,6 @@ import type { SchemaVersion } from "./SchemaVersion"; /** * `public.eql_v3_text_search_ore` — search domain. * - * Operators: `=` `<>` `<` `<=` `>` `>=` `@>` `<@`. Required keys: `v` `i` `c` `hm` `ob` `bf`. + * Operators: `=` `<>` `<` `<=` `>` `>=` `@@`. Required keys: `v` `i` `c` `hm` `ob` `bf`. */ export type TextSearchOre = { v: SchemaVersion, i: Identifier, c: Ciphertext, hm: Hmac256, ob: OreBlock256, bf: BloomFilter, }; diff --git a/packages/eql/src/generated/v3/TextSearchOreQuery.ts b/packages/eql/src/generated/v3/TextSearchOreQuery.ts index 8e7bd1066..3b3069a30 100644 --- a/packages/eql/src/generated/v3/TextSearchOreQuery.ts +++ b/packages/eql/src/generated/v3/TextSearchOreQuery.ts @@ -8,6 +8,6 @@ import type { SchemaVersion } from "./SchemaVersion"; /** * `eql_v3.query_text_search_ore` — search domain query operand. * - * Operators: `=` `<>` `<` `<=` `>` `>=` `@>` `<@`. Required keys: `v` `i` `hm` `ob` `bf`. + * Operators: `=` `<>` `<` `<=` `>` `>=` `@@`. Required keys: `v` `i` `hm` `ob` `bf`. */ export type TextSearchOreQuery = { v: SchemaVersion, i: Identifier, hm: Hmac256, ob: OreBlock256, bf: BloomFilter, }; diff --git a/packages/eql/src/generated/v3/TextSearchQuery.ts b/packages/eql/src/generated/v3/TextSearchQuery.ts index 7f29899eb..c2e5207ad 100644 --- a/packages/eql/src/generated/v3/TextSearchQuery.ts +++ b/packages/eql/src/generated/v3/TextSearchQuery.ts @@ -8,6 +8,6 @@ import type { SchemaVersion } from "./SchemaVersion"; /** * `eql_v3.query_text_search` — search domain query operand. * - * Operators: `=` `<>` `<` `<=` `>` `>=` `@>` `<@`. Required keys: `v` `i` `hm` `op` `bf`. + * Operators: `=` `<>` `<` `<=` `>` `>=` `@@`. Required keys: `v` `i` `hm` `op` `bf`. */ export type TextSearchQuery = { v: SchemaVersion, i: Identifier, hm: Hmac256, op: OpeCllw, bf: BloomFilter, }; diff --git a/src/v3/scalars/bigint/bigint_eq_functions.sql b/src/v3/scalars/bigint/bigint_eq_functions.sql index a8d8e6505..efa9f30f9 100644 --- a/src/v3/scalars/bigint/bigint_eq_functions.sql +++ b/src/v3/scalars/bigint/bigint_eq_functions.sql @@ -64,342 +64,574 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) <> eql_v3.eq_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a jsonb ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a jsonb ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a jsonb ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a jsonb ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a jsonb ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a jsonb ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param selector text ---! @return public.eql_v3_bigint_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_bigint_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_eq, selector text) RETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param selector integer ---! @return public.eql_v3_bigint_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_bigint_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_eq, selector integer) RETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a jsonb ---! @param selector public.eql_v3_bigint_eq ---! @return public.eql_v3_bigint_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator +--! @return public.eql_v3_bigint_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_eq) RETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a jsonb ---! @param selector public.eql_v3_bigint_eq ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_eq) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a jsonb ---! @param b public.eql_v3_bigint_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$ diff --git a/src/v3/scalars/bigint/bigint_eq_operators.sql b/src/v3/scalars/bigint/bigint_eq_operators.sql index be3c8e58d..0bb312689 100644 --- a/src/v3/scalars/bigint/bigint_eq_operators.sql +++ b/src/v3/scalars/bigint/bigint_eq_operators.sql @@ -182,6 +182,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonpath diff --git a/src/v3/scalars/bigint/bigint_functions.sql b/src/v3/scalars/bigint/bigint_functions.sql index 7a4cf8b70..1acd0d503 100644 --- a/src/v3/scalars/bigint/bigint_functions.sql +++ b/src/v3/scalars/bigint/bigint_functions.sql @@ -7,396 +7,658 @@ --! @brief Functions for public.eql_v3_bigint. --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param selector text ---! @return public.eql_v3_bigint +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_bigint never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint, selector text) RETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param selector integer ---! @return public.eql_v3_bigint +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_bigint never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint, selector integer) RETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param selector public.eql_v3_bigint ---! @return public.eql_v3_bigint +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_bigint right operand of the blocked operator +--! @return public.eql_v3_bigint never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint) RETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param selector public.eql_v3_bigint ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_bigint right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint, b public.eql_v3_bigint) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$ diff --git a/src/v3/scalars/bigint/bigint_operators.sql b/src/v3/scalars/bigint/bigint_operators.sql index 2b1b1ff57..46170b430 100644 --- a/src/v3/scalars/bigint/bigint_operators.sql +++ b/src/v3/scalars/bigint/bigint_operators.sql @@ -176,6 +176,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonpath diff --git a/src/v3/scalars/bigint/bigint_ord_functions.sql b/src/v3/scalars/bigint/bigint_ord_functions.sql index 46fac9db8..77acfe426 100644 --- a/src/v3/scalars/bigint/bigint_ord_functions.sql +++ b/src/v3/scalars/bigint/bigint_ord_functions.sql @@ -160,234 +160,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b public.eql_v3_bigint_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b public.eql_v3_bigint_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param selector text ---! @return public.eql_v3_bigint_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_bigint_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord, selector text) RETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param selector integer ---! @return public.eql_v3_bigint_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_bigint_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord, selector integer) RETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a jsonb ---! @param selector public.eql_v3_bigint_ord ---! @return public.eql_v3_bigint_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator +--! @return public.eql_v3_bigint_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_ord) RETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a jsonb ---! @param selector public.eql_v3_bigint_ord ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_ord) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_bigint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b public.eql_v3_bigint_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$ diff --git a/src/v3/scalars/bigint/bigint_ord_ope_functions.sql b/src/v3/scalars/bigint/bigint_ord_ope_functions.sql index d52783242..478a60db1 100644 --- a/src/v3/scalars/bigint/bigint_ord_ope_functions.sql +++ b/src/v3/scalars/bigint/bigint_ord_ope_functions.sql @@ -160,234 +160,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param selector text ---! @return public.eql_v3_bigint_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ope, selector text) RETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param selector integer ---! @return public.eql_v3_bigint_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ope, selector integer) RETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_bigint_ord_ope ---! @return public.eql_v3_bigint_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_ord_ope) RETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_bigint_ord_ope ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_bigint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$ diff --git a/src/v3/scalars/bigint/bigint_ord_ope_operators.sql b/src/v3/scalars/bigint/bigint_ord_ope_operators.sql index acfb3f902..65c515f20 100644 --- a/src/v3/scalars/bigint/bigint_ord_ope_operators.sql +++ b/src/v3/scalars/bigint/bigint_ord_ope_operators.sql @@ -194,6 +194,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonpath diff --git a/src/v3/scalars/bigint/bigint_ord_operators.sql b/src/v3/scalars/bigint/bigint_ord_operators.sql index 88d42e455..c86e76306 100644 --- a/src/v3/scalars/bigint/bigint_ord_operators.sql +++ b/src/v3/scalars/bigint/bigint_ord_operators.sql @@ -194,6 +194,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonpath diff --git a/src/v3/scalars/bigint/bigint_ord_ore_functions.sql b/src/v3/scalars/bigint/bigint_ord_ore_functions.sql index f3c503b2a..0441c8186 100644 --- a/src/v3/scalars/bigint/bigint_ord_ore_functions.sql +++ b/src/v3/scalars/bigint/bigint_ord_ore_functions.sql @@ -161,234 +161,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) >= eql_v3.ord_term_ore(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param selector text ---! @return public.eql_v3_bigint_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ore, selector text) RETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param selector integer ---! @return public.eql_v3_bigint_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ore, selector integer) RETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_bigint_ord_ore ---! @return public.eql_v3_bigint_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_ord_ore) RETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_bigint_ord_ore ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$ diff --git a/src/v3/scalars/bigint/bigint_ord_ore_operators.sql b/src/v3/scalars/bigint/bigint_ord_ore_operators.sql index ac2286a6e..2f87146cc 100644 --- a/src/v3/scalars/bigint/bigint_ord_ore_operators.sql +++ b/src/v3/scalars/bigint/bigint_ord_ore_operators.sql @@ -194,6 +194,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonpath diff --git a/src/v3/scalars/boolean/boolean_functions.sql b/src/v3/scalars/boolean/boolean_functions.sql index 74b693434..c34730227 100644 --- a/src/v3/scalars/boolean/boolean_functions.sql +++ b/src/v3/scalars/boolean/boolean_functions.sql @@ -7,396 +7,658 @@ --! @brief Functions for public.eql_v3_boolean. --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param selector text ---! @return public.eql_v3_boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_boolean, selector text) RETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param selector integer ---! @return public.eql_v3_boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_boolean, selector integer) RETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param selector public.eql_v3_boolean ---! @return public.eql_v3_boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_boolean right operand of the blocked operator +--! @return public.eql_v3_boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_boolean) RETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_boolean, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_boolean, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param selector public.eql_v3_boolean ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_boolean right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_boolean) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_boolean, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_boolean, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_boolean, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_boolean, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_boolean, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_boolean, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_boolean, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_boolean, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_boolean, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_boolean, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_boolean, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_boolean, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_boolean, b public.eql_v3_boolean) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_boolean, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_boolean) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$ diff --git a/src/v3/scalars/boolean/boolean_operators.sql b/src/v3/scalars/boolean/boolean_operators.sql index e3f5782c2..004793512 100644 --- a/src/v3/scalars/boolean/boolean_operators.sql +++ b/src/v3/scalars/boolean/boolean_operators.sql @@ -176,6 +176,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonpath diff --git a/src/v3/scalars/date/date_eq_functions.sql b/src/v3/scalars/date/date_eq_functions.sql index 15532406e..c72d2b9d1 100644 --- a/src/v3/scalars/date/date_eq_functions.sql +++ b/src/v3/scalars/date/date_eq_functions.sql @@ -64,342 +64,574 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) <> eql_v3.eq_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a jsonb ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a jsonb ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a jsonb ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a jsonb ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a jsonb ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a jsonb ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param selector text ---! @return public.eql_v3_date_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_date_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_eq, selector text) RETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param selector integer ---! @return public.eql_v3_date_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_date_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_eq, selector integer) RETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a jsonb ---! @param selector public.eql_v3_date_eq ---! @return public.eql_v3_date_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_date_eq right operand of the blocked operator +--! @return public.eql_v3_date_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_eq) RETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a jsonb ---! @param selector public.eql_v3_date_eq ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_date_eq right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_eq) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_eq, b public.eql_v3_date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a jsonb ---! @param b public.eql_v3_date_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$ diff --git a/src/v3/scalars/date/date_eq_operators.sql b/src/v3/scalars/date/date_eq_operators.sql index a9fb143e8..6fa719cc4 100644 --- a/src/v3/scalars/date/date_eq_operators.sql +++ b/src/v3/scalars/date/date_eq_operators.sql @@ -182,6 +182,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonpath diff --git a/src/v3/scalars/date/date_functions.sql b/src/v3/scalars/date/date_functions.sql index 59c5d0bce..463bbdca5 100644 --- a/src/v3/scalars/date/date_functions.sql +++ b/src/v3/scalars/date/date_functions.sql @@ -7,396 +7,658 @@ --! @brief Functions for public.eql_v3_date. --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param selector text ---! @return public.eql_v3_date +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_date never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date, selector text) RETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param selector integer ---! @return public.eql_v3_date +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_date never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date, selector integer) RETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param selector public.eql_v3_date ---! @return public.eql_v3_date +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_date right operand of the blocked operator +--! @return public.eql_v3_date never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date) RETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param selector public.eql_v3_date ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_date right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date. +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date, b public.eql_v3_date) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$ diff --git a/src/v3/scalars/date/date_operators.sql b/src/v3/scalars/date/date_operators.sql index 4dba9c905..daad33efe 100644 --- a/src/v3/scalars/date/date_operators.sql +++ b/src/v3/scalars/date/date_operators.sql @@ -176,6 +176,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_date, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_date, RIGHTARG = jsonpath diff --git a/src/v3/scalars/date/date_ord_functions.sql b/src/v3/scalars/date/date_ord_functions.sql index 446fd9106..baf000ced 100644 --- a/src/v3/scalars/date/date_ord_functions.sql +++ b/src/v3/scalars/date/date_ord_functions.sql @@ -160,234 +160,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b public.eql_v3_date_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b public.eql_v3_date_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b public.eql_v3_date_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a jsonb ---! @param b public.eql_v3_date_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b public.eql_v3_date_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b public.eql_v3_date_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b public.eql_v3_date_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a jsonb ---! @param b public.eql_v3_date_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param selector text ---! @return public.eql_v3_date_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_date_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord, selector text) RETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param selector integer ---! @return public.eql_v3_date_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_date_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord, selector integer) RETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a jsonb ---! @param selector public.eql_v3_date_ord ---! @return public.eql_v3_date_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_date_ord right operand of the blocked operator +--! @return public.eql_v3_date_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_ord) RETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a jsonb ---! @param selector public.eql_v3_date_ord ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_date_ord right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_ord) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b public.eql_v3_date_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord, b public.eql_v3_date_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_date_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b public.eql_v3_date_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b public.eql_v3_date_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord, b public.eql_v3_date_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a jsonb ---! @param b public.eql_v3_date_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$ diff --git a/src/v3/scalars/date/date_ord_ope_functions.sql b/src/v3/scalars/date/date_ord_ope_functions.sql index fc794db9c..9cc2a88d0 100644 --- a/src/v3/scalars/date/date_ord_ope_functions.sql +++ b/src/v3/scalars/date/date_ord_ope_functions.sql @@ -160,234 +160,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b public.eql_v3_date_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_date_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b public.eql_v3_date_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_date_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param selector text ---! @return public.eql_v3_date_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_date_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ope, selector text) RETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param selector integer ---! @return public.eql_v3_date_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_date_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ope, selector integer) RETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_date_ord_ope ---! @return public.eql_v3_date_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator +--! @return public.eql_v3_date_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_ord_ope) RETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_date_ord_ope ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_date_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b public.eql_v3_date_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_date_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$ diff --git a/src/v3/scalars/date/date_ord_ope_operators.sql b/src/v3/scalars/date/date_ord_ope_operators.sql index 00c5491d7..b511e73a0 100644 --- a/src/v3/scalars/date/date_ord_ope_operators.sql +++ b/src/v3/scalars/date/date_ord_ope_operators.sql @@ -194,6 +194,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonpath diff --git a/src/v3/scalars/date/date_ord_operators.sql b/src/v3/scalars/date/date_ord_operators.sql index 1c05d6fb9..28e0bac49 100644 --- a/src/v3/scalars/date/date_ord_operators.sql +++ b/src/v3/scalars/date/date_ord_operators.sql @@ -194,6 +194,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonpath diff --git a/src/v3/scalars/date/date_ord_ore_functions.sql b/src/v3/scalars/date/date_ord_ore_functions.sql index f4f21adf2..a84903fb3 100644 --- a/src/v3/scalars/date/date_ord_ore_functions.sql +++ b/src/v3/scalars/date/date_ord_ore_functions.sql @@ -161,234 +161,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) >= eql_v3.ord_term_ore(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b public.eql_v3_date_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_date_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b public.eql_v3_date_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_date_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param selector text ---! @return public.eql_v3_date_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_date_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ore, selector text) RETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param selector integer ---! @return public.eql_v3_date_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_date_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ore, selector integer) RETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_date_ord_ore ---! @return public.eql_v3_date_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator +--! @return public.eql_v3_date_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_ord_ore) RETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_date_ord_ore ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_date_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b public.eql_v3_date_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_date_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$ diff --git a/src/v3/scalars/date/date_ord_ore_operators.sql b/src/v3/scalars/date/date_ord_ore_operators.sql index 543b0c767..28a9cc7ed 100644 --- a/src/v3/scalars/date/date_ord_ore_operators.sql +++ b/src/v3/scalars/date/date_ord_ore_operators.sql @@ -194,6 +194,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonpath diff --git a/src/v3/scalars/double/double_eq_functions.sql b/src/v3/scalars/double/double_eq_functions.sql index 61063a411..49b33c2f6 100644 --- a/src/v3/scalars/double/double_eq_functions.sql +++ b/src/v3/scalars/double/double_eq_functions.sql @@ -64,342 +64,574 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) <> eql_v3.eq_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param selector text ---! @return public.eql_v3_double_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_double_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_eq, selector text) RETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param selector integer ---! @return public.eql_v3_double_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_double_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_eq, selector integer) RETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param selector public.eql_v3_double_eq ---! @return public.eql_v3_double_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_double_eq right operand of the blocked operator +--! @return public.eql_v3_double_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double_eq) RETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param selector public.eql_v3_double_eq ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_double_eq right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double_eq) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_eq, b public.eql_v3_double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_eq, b public.eql_v3_double_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$ diff --git a/src/v3/scalars/double/double_eq_operators.sql b/src/v3/scalars/double/double_eq_operators.sql index 44114cbae..46d0ae5e6 100644 --- a/src/v3/scalars/double/double_eq_operators.sql +++ b/src/v3/scalars/double/double_eq_operators.sql @@ -182,6 +182,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonpath diff --git a/src/v3/scalars/double/double_functions.sql b/src/v3/scalars/double/double_functions.sql index 45e6303cc..80a425549 100644 --- a/src/v3/scalars/double/double_functions.sql +++ b/src/v3/scalars/double/double_functions.sql @@ -7,396 +7,658 @@ --! @brief Functions for public.eql_v3_double. --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param selector text ---! @return public.eql_v3_double +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_double never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double, selector text) RETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param selector integer ---! @return public.eql_v3_double +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_double never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double, selector integer) RETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param selector public.eql_v3_double ---! @return public.eql_v3_double +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_double right operand of the blocked operator +--! @return public.eql_v3_double never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double) RETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param selector public.eql_v3_double ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_double right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double. +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double, b public.eql_v3_double) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$ diff --git a/src/v3/scalars/double/double_operators.sql b/src/v3/scalars/double/double_operators.sql index 777657141..4e8da085a 100644 --- a/src/v3/scalars/double/double_operators.sql +++ b/src/v3/scalars/double/double_operators.sql @@ -176,6 +176,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_double, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_double, RIGHTARG = jsonpath diff --git a/src/v3/scalars/double/double_ord_functions.sql b/src/v3/scalars/double/double_ord_functions.sql index bcc651933..2554ce56c 100644 --- a/src/v3/scalars/double/double_ord_functions.sql +++ b/src/v3/scalars/double/double_ord_functions.sql @@ -160,234 +160,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b public.eql_v3_double_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b public.eql_v3_double_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord, b public.eql_v3_double_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a jsonb ---! @param b public.eql_v3_double_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b public.eql_v3_double_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b public.eql_v3_double_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord, b public.eql_v3_double_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a jsonb ---! @param b public.eql_v3_double_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param selector text ---! @return public.eql_v3_double_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_double_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord, selector text) RETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param selector integer ---! @return public.eql_v3_double_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_double_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord, selector integer) RETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a jsonb ---! @param selector public.eql_v3_double_ord ---! @return public.eql_v3_double_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_double_ord right operand of the blocked operator +--! @return public.eql_v3_double_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double_ord) RETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a jsonb ---! @param selector public.eql_v3_double_ord ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_double_ord right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double_ord) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b public.eql_v3_double_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord, b public.eql_v3_double_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_double_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b public.eql_v3_double_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b public.eql_v3_double_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord, b public.eql_v3_double_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a jsonb ---! @param b public.eql_v3_double_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$ diff --git a/src/v3/scalars/double/double_ord_ope_functions.sql b/src/v3/scalars/double/double_ord_ope_functions.sql index 411baa4b8..b3862e5e4 100644 --- a/src/v3/scalars/double/double_ord_ope_functions.sql +++ b/src/v3/scalars/double/double_ord_ope_functions.sql @@ -160,234 +160,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b public.eql_v3_double_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_double_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b public.eql_v3_double_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_double_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param selector text ---! @return public.eql_v3_double_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_double_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord_ope, selector text) RETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param selector integer ---! @return public.eql_v3_double_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_double_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord_ope, selector integer) RETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_double_ord_ope ---! @return public.eql_v3_double_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator +--! @return public.eql_v3_double_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double_ord_ope) RETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_double_ord_ope ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_double_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b public.eql_v3_double_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_double_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$ diff --git a/src/v3/scalars/double/double_ord_ope_operators.sql b/src/v3/scalars/double/double_ord_ope_operators.sql index 7e45b75af..e62acca0e 100644 --- a/src/v3/scalars/double/double_ord_ope_operators.sql +++ b/src/v3/scalars/double/double_ord_ope_operators.sql @@ -194,6 +194,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonpath diff --git a/src/v3/scalars/double/double_ord_operators.sql b/src/v3/scalars/double/double_ord_operators.sql index 80548a358..6178c72f9 100644 --- a/src/v3/scalars/double/double_ord_operators.sql +++ b/src/v3/scalars/double/double_ord_operators.sql @@ -194,6 +194,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonpath diff --git a/src/v3/scalars/double/double_ord_ore_functions.sql b/src/v3/scalars/double/double_ord_ore_functions.sql index 68560a9a6..9c65feb22 100644 --- a/src/v3/scalars/double/double_ord_ore_functions.sql +++ b/src/v3/scalars/double/double_ord_ore_functions.sql @@ -161,234 +161,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) >= eql_v3.ord_term_ore(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b public.eql_v3_double_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_double_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b public.eql_v3_double_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_double_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param selector text ---! @return public.eql_v3_double_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_double_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord_ore, selector text) RETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param selector integer ---! @return public.eql_v3_double_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_double_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord_ore, selector integer) RETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_double_ord_ore ---! @return public.eql_v3_double_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator +--! @return public.eql_v3_double_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double_ord_ore) RETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_double_ord_ore ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_double_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b public.eql_v3_double_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_double_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$ diff --git a/src/v3/scalars/double/double_ord_ore_operators.sql b/src/v3/scalars/double/double_ord_ore_operators.sql index 5c0676cff..6057dbbe7 100644 --- a/src/v3/scalars/double/double_ord_ore_operators.sql +++ b/src/v3/scalars/double/double_ord_ore_operators.sql @@ -194,6 +194,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonpath diff --git a/src/v3/scalars/integer/integer_eq_functions.sql b/src/v3/scalars/integer/integer_eq_functions.sql index 12190994c..80e3e01d6 100644 --- a/src/v3/scalars/integer/integer_eq_functions.sql +++ b/src/v3/scalars/integer/integer_eq_functions.sql @@ -64,342 +64,574 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) <> eql_v3.eq_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param selector text ---! @return public.eql_v3_integer_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_integer_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_eq, selector text) RETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param selector integer ---! @return public.eql_v3_integer_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_integer_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_eq, selector integer) RETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param selector public.eql_v3_integer_eq ---! @return public.eql_v3_integer_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_integer_eq right operand of the blocked operator +--! @return public.eql_v3_integer_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_eq) RETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param selector public.eql_v3_integer_eq ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_integer_eq right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_eq) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$ diff --git a/src/v3/scalars/integer/integer_eq_operators.sql b/src/v3/scalars/integer/integer_eq_operators.sql index c24e48b3a..2848d6fe1 100644 --- a/src/v3/scalars/integer/integer_eq_operators.sql +++ b/src/v3/scalars/integer/integer_eq_operators.sql @@ -182,6 +182,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonpath diff --git a/src/v3/scalars/integer/integer_functions.sql b/src/v3/scalars/integer/integer_functions.sql index b2181e642..c6fe4631d 100644 --- a/src/v3/scalars/integer/integer_functions.sql +++ b/src/v3/scalars/integer/integer_functions.sql @@ -7,396 +7,658 @@ --! @brief Functions for public.eql_v3_integer. --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param selector text ---! @return public.eql_v3_integer +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_integer never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer, selector text) RETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param selector integer ---! @return public.eql_v3_integer +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_integer never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer, selector integer) RETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param selector public.eql_v3_integer ---! @return public.eql_v3_integer +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_integer right operand of the blocked operator +--! @return public.eql_v3_integer never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer) RETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param selector public.eql_v3_integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer. +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$ diff --git a/src/v3/scalars/integer/integer_operators.sql b/src/v3/scalars/integer/integer_operators.sql index 752f39a73..476bbd5cf 100644 --- a/src/v3/scalars/integer/integer_operators.sql +++ b/src/v3/scalars/integer/integer_operators.sql @@ -176,6 +176,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_integer, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_integer, RIGHTARG = jsonpath diff --git a/src/v3/scalars/integer/integer_ord_functions.sql b/src/v3/scalars/integer/integer_ord_functions.sql index 67ade26b0..ae6de7ef8 100644 --- a/src/v3/scalars/integer/integer_ord_functions.sql +++ b/src/v3/scalars/integer/integer_ord_functions.sql @@ -160,234 +160,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b public.eql_v3_integer_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b public.eql_v3_integer_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a jsonb ---! @param b public.eql_v3_integer_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b public.eql_v3_integer_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b public.eql_v3_integer_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a jsonb ---! @param b public.eql_v3_integer_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param selector text ---! @return public.eql_v3_integer_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_integer_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord, selector text) RETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param selector integer ---! @return public.eql_v3_integer_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_integer_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord, selector integer) RETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a jsonb ---! @param selector public.eql_v3_integer_ord ---! @return public.eql_v3_integer_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_integer_ord right operand of the blocked operator +--! @return public.eql_v3_integer_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_ord) RETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a jsonb ---! @param selector public.eql_v3_integer_ord ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_integer_ord right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_ord) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b public.eql_v3_integer_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_integer_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b public.eql_v3_integer_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b public.eql_v3_integer_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a jsonb ---! @param b public.eql_v3_integer_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$ diff --git a/src/v3/scalars/integer/integer_ord_ope_functions.sql b/src/v3/scalars/integer/integer_ord_ope_functions.sql index 49ca734ce..68d4b9e2a 100644 --- a/src/v3/scalars/integer/integer_ord_ope_functions.sql +++ b/src/v3/scalars/integer/integer_ord_ope_functions.sql @@ -160,234 +160,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_integer_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_integer_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param selector text ---! @return public.eql_v3_integer_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_integer_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ope, selector text) RETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param selector integer ---! @return public.eql_v3_integer_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_integer_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ope, selector integer) RETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_integer_ord_ope ---! @return public.eql_v3_integer_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @return public.eql_v3_integer_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_ord_ope) RETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_integer_ord_ope ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_integer_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_integer_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$ diff --git a/src/v3/scalars/integer/integer_ord_ope_operators.sql b/src/v3/scalars/integer/integer_ord_ope_operators.sql index 2822857bf..8f8c319a8 100644 --- a/src/v3/scalars/integer/integer_ord_ope_operators.sql +++ b/src/v3/scalars/integer/integer_ord_ope_operators.sql @@ -194,6 +194,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonpath diff --git a/src/v3/scalars/integer/integer_ord_operators.sql b/src/v3/scalars/integer/integer_ord_operators.sql index a2e1a6f7f..f5d9dcaa5 100644 --- a/src/v3/scalars/integer/integer_ord_operators.sql +++ b/src/v3/scalars/integer/integer_ord_operators.sql @@ -194,6 +194,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonpath diff --git a/src/v3/scalars/integer/integer_ord_ore_functions.sql b/src/v3/scalars/integer/integer_ord_ore_functions.sql index 2299c1cb9..e4518aa9b 100644 --- a/src/v3/scalars/integer/integer_ord_ore_functions.sql +++ b/src/v3/scalars/integer/integer_ord_ore_functions.sql @@ -161,234 +161,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) >= eql_v3.ord_term_ore(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_integer_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_integer_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param selector text ---! @return public.eql_v3_integer_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_integer_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ore, selector text) RETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param selector integer ---! @return public.eql_v3_integer_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_integer_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ore, selector integer) RETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_integer_ord_ore ---! @return public.eql_v3_integer_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @return public.eql_v3_integer_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_ord_ore) RETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_integer_ord_ore ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_integer_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_integer_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$ diff --git a/src/v3/scalars/integer/integer_ord_ore_operators.sql b/src/v3/scalars/integer/integer_ord_ore_operators.sql index 3d9304891..ed50f6297 100644 --- a/src/v3/scalars/integer/integer_ord_ore_operators.sql +++ b/src/v3/scalars/integer/integer_ord_ore_operators.sql @@ -194,6 +194,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonpath diff --git a/src/v3/scalars/json/json_functions.sql b/src/v3/scalars/json/json_functions.sql index 3727c205c..ad5ca52a7 100644 --- a/src/v3/scalars/json/json_functions.sql +++ b/src/v3/scalars/json/json_functions.sql @@ -7,396 +7,658 @@ --! @brief Functions for public.eql_v3_json. --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a jsonb ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a jsonb ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a jsonb ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a jsonb ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a jsonb ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a jsonb ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a jsonb ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a jsonb ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param selector text ---! @return public.eql_v3_json +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_json never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_json, selector text) RETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param selector integer ---! @return public.eql_v3_json +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_json never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_json, selector integer) RETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a jsonb ---! @param selector public.eql_v3_json ---! @return public.eql_v3_json +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_json right operand of the blocked operator +--! @return public.eql_v3_json never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_json) RETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_json, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_json, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a jsonb ---! @param selector public.eql_v3_json ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_json right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_json) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_json, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_json, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_json, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_json, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_json, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_json, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_json) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_json. +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_json, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_json, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_json, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_json, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_json, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_json, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_json, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b public.eql_v3_json ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_json, b public.eql_v3_json) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_json, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a jsonb ---! @param b public.eql_v3_json ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_json) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$ diff --git a/src/v3/scalars/json/json_operators.sql b/src/v3/scalars/json/json_operators.sql index 40de7fd3b..21cdfd15b 100644 --- a/src/v3/scalars/json/json_operators.sql +++ b/src/v3/scalars/json/json_operators.sql @@ -176,6 +176,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_json, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_json +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath diff --git a/src/v3/scalars/numeric/numeric_eq_functions.sql b/src/v3/scalars/numeric/numeric_eq_functions.sql index 9d68b696e..fe3ebd54f 100644 --- a/src/v3/scalars/numeric/numeric_eq_functions.sql +++ b/src/v3/scalars/numeric/numeric_eq_functions.sql @@ -64,342 +64,574 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_numeric_eq) <> eql_v3.eq_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a jsonb ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a jsonb ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a jsonb ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a jsonb ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a jsonb ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a jsonb ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param selector text ---! @return public.eql_v3_numeric_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_numeric_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_eq, selector text) RETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param selector integer ---! @return public.eql_v3_numeric_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_numeric_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_eq, selector integer) RETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a jsonb ---! @param selector public.eql_v3_numeric_eq ---! @return public.eql_v3_numeric_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator +--! @return public.eql_v3_numeric_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric_eq) RETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a jsonb ---! @param selector public.eql_v3_numeric_eq ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric_eq) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b public.eql_v3_numeric_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a jsonb ---! @param b public.eql_v3_numeric_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$ diff --git a/src/v3/scalars/numeric/numeric_eq_operators.sql b/src/v3/scalars/numeric/numeric_eq_operators.sql index 8708ce45c..1b9a16b7c 100644 --- a/src/v3/scalars/numeric/numeric_eq_operators.sql +++ b/src/v3/scalars/numeric/numeric_eq_operators.sql @@ -182,6 +182,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonpath diff --git a/src/v3/scalars/numeric/numeric_functions.sql b/src/v3/scalars/numeric/numeric_functions.sql index 0364c10dd..82001f519 100644 --- a/src/v3/scalars/numeric/numeric_functions.sql +++ b/src/v3/scalars/numeric/numeric_functions.sql @@ -7,396 +7,658 @@ --! @brief Functions for public.eql_v3_numeric. --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param selector text ---! @return public.eql_v3_numeric +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_numeric never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric, selector text) RETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param selector integer ---! @return public.eql_v3_numeric +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_numeric never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric, selector integer) RETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param selector public.eql_v3_numeric ---! @return public.eql_v3_numeric +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_numeric right operand of the blocked operator +--! @return public.eql_v3_numeric never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric) RETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param selector public.eql_v3_numeric ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_numeric right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$ diff --git a/src/v3/scalars/numeric/numeric_operators.sql b/src/v3/scalars/numeric/numeric_operators.sql index 4024eca7d..9beeedd2b 100644 --- a/src/v3/scalars/numeric/numeric_operators.sql +++ b/src/v3/scalars/numeric/numeric_operators.sql @@ -176,6 +176,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonpath diff --git a/src/v3/scalars/numeric/numeric_ord_functions.sql b/src/v3/scalars/numeric/numeric_ord_functions.sql index de80c4841..bd7d97471 100644 --- a/src/v3/scalars/numeric/numeric_ord_functions.sql +++ b/src/v3/scalars/numeric/numeric_ord_functions.sql @@ -160,234 +160,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param selector text ---! @return public.eql_v3_numeric_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_numeric_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord, selector text) RETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param selector integer ---! @return public.eql_v3_numeric_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_numeric_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord, selector integer) RETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param selector public.eql_v3_numeric_ord ---! @return public.eql_v3_numeric_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator +--! @return public.eql_v3_numeric_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric_ord) RETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param selector public.eql_v3_numeric_ord ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric_ord) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_numeric_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$ diff --git a/src/v3/scalars/numeric/numeric_ord_ope_functions.sql b/src/v3/scalars/numeric/numeric_ord_ope_functions.sql index cf57d1a94..5f2f4ec32 100644 --- a/src/v3/scalars/numeric/numeric_ord_ope_functions.sql +++ b/src/v3/scalars/numeric/numeric_ord_ope_functions.sql @@ -160,234 +160,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param selector text ---! @return public.eql_v3_numeric_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ope, selector text) RETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param selector integer ---! @return public.eql_v3_numeric_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ope, selector integer) RETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_numeric_ord_ope ---! @return public.eql_v3_numeric_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric_ord_ope) RETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_numeric_ord_ope ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_numeric_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$ diff --git a/src/v3/scalars/numeric/numeric_ord_ope_operators.sql b/src/v3/scalars/numeric/numeric_ord_ope_operators.sql index dac46f640..26f446e46 100644 --- a/src/v3/scalars/numeric/numeric_ord_ope_operators.sql +++ b/src/v3/scalars/numeric/numeric_ord_ope_operators.sql @@ -194,6 +194,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonpath diff --git a/src/v3/scalars/numeric/numeric_ord_operators.sql b/src/v3/scalars/numeric/numeric_ord_operators.sql index a742836a7..c3f29d217 100644 --- a/src/v3/scalars/numeric/numeric_ord_operators.sql +++ b/src/v3/scalars/numeric/numeric_ord_operators.sql @@ -194,6 +194,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonpath diff --git a/src/v3/scalars/numeric/numeric_ord_ore_functions.sql b/src/v3/scalars/numeric/numeric_ord_ore_functions.sql index 43efdb75a..5481863bc 100644 --- a/src/v3/scalars/numeric/numeric_ord_ore_functions.sql +++ b/src/v3/scalars/numeric/numeric_ord_ore_functions.sql @@ -161,234 +161,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) >= eql_v3.ord_term_ore(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param selector text ---! @return public.eql_v3_numeric_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ore, selector text) RETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param selector integer ---! @return public.eql_v3_numeric_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ore, selector integer) RETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_numeric_ord_ore ---! @return public.eql_v3_numeric_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric_ord_ore) RETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_numeric_ord_ore ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_numeric_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$ diff --git a/src/v3/scalars/numeric/numeric_ord_ore_operators.sql b/src/v3/scalars/numeric/numeric_ord_ore_operators.sql index b1983d0a7..ed2e72be8 100644 --- a/src/v3/scalars/numeric/numeric_ord_ore_operators.sql +++ b/src/v3/scalars/numeric/numeric_ord_ore_operators.sql @@ -194,6 +194,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonpath diff --git a/src/v3/scalars/real/real_eq_functions.sql b/src/v3/scalars/real/real_eq_functions.sql index 6fed38e62..a7b504d59 100644 --- a/src/v3/scalars/real/real_eq_functions.sql +++ b/src/v3/scalars/real/real_eq_functions.sql @@ -64,342 +64,574 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) <> eql_v3.eq_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a jsonb ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a jsonb ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a jsonb ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a jsonb ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a jsonb ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a jsonb ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param selector text ---! @return public.eql_v3_real_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_real_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_eq, selector text) RETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param selector integer ---! @return public.eql_v3_real_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_real_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_eq, selector integer) RETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a jsonb ---! @param selector public.eql_v3_real_eq ---! @return public.eql_v3_real_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_real_eq right operand of the blocked operator +--! @return public.eql_v3_real_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_eq) RETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a jsonb ---! @param selector public.eql_v3_real_eq ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_real_eq right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_eq) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a jsonb ---! @param b public.eql_v3_real_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$ diff --git a/src/v3/scalars/real/real_eq_operators.sql b/src/v3/scalars/real/real_eq_operators.sql index d2a8d9dce..9ddac1035 100644 --- a/src/v3/scalars/real/real_eq_operators.sql +++ b/src/v3/scalars/real/real_eq_operators.sql @@ -182,6 +182,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonpath diff --git a/src/v3/scalars/real/real_functions.sql b/src/v3/scalars/real/real_functions.sql index 4f5281e7e..2d68e57ca 100644 --- a/src/v3/scalars/real/real_functions.sql +++ b/src/v3/scalars/real/real_functions.sql @@ -7,396 +7,658 @@ --! @brief Functions for public.eql_v3_real. --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a jsonb ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a jsonb ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a jsonb ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a jsonb ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a jsonb ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a jsonb ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a jsonb ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a jsonb ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param selector text ---! @return public.eql_v3_real +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_real never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real, selector text) RETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param selector integer ---! @return public.eql_v3_real +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_real never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real, selector integer) RETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a jsonb ---! @param selector public.eql_v3_real ---! @return public.eql_v3_real +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_real right operand of the blocked operator +--! @return public.eql_v3_real never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real) RETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a jsonb ---! @param selector public.eql_v3_real ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_real right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real. +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real, b public.eql_v3_real) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a jsonb ---! @param b public.eql_v3_real ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$ diff --git a/src/v3/scalars/real/real_operators.sql b/src/v3/scalars/real/real_operators.sql index 9195f5e27..99ed1e23d 100644 --- a/src/v3/scalars/real/real_operators.sql +++ b/src/v3/scalars/real/real_operators.sql @@ -176,6 +176,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_real, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_real, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_real, RIGHTARG = jsonpath diff --git a/src/v3/scalars/real/real_ord_functions.sql b/src/v3/scalars/real/real_ord_functions.sql index fd6bcbe7f..e3631653b 100644 --- a/src/v3/scalars/real/real_ord_functions.sql +++ b/src/v3/scalars/real/real_ord_functions.sql @@ -160,234 +160,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b public.eql_v3_real_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b public.eql_v3_real_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a jsonb ---! @param b public.eql_v3_real_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b public.eql_v3_real_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b public.eql_v3_real_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a jsonb ---! @param b public.eql_v3_real_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param selector text ---! @return public.eql_v3_real_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_real_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord, selector text) RETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param selector integer ---! @return public.eql_v3_real_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_real_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord, selector integer) RETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a jsonb ---! @param selector public.eql_v3_real_ord ---! @return public.eql_v3_real_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_real_ord right operand of the blocked operator +--! @return public.eql_v3_real_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_ord) RETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a jsonb ---! @param selector public.eql_v3_real_ord ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_real_ord right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_ord) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b public.eql_v3_real_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord, b public.eql_v3_real_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_real_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b public.eql_v3_real_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b public.eql_v3_real_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a jsonb ---! @param b public.eql_v3_real_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$ diff --git a/src/v3/scalars/real/real_ord_ope_functions.sql b/src/v3/scalars/real/real_ord_ope_functions.sql index 88d14c802..18da5b294 100644 --- a/src/v3/scalars/real/real_ord_ope_functions.sql +++ b/src/v3/scalars/real/real_ord_ope_functions.sql @@ -160,234 +160,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b public.eql_v3_real_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_real_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b public.eql_v3_real_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_real_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param selector text ---! @return public.eql_v3_real_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_real_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ope, selector text) RETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param selector integer ---! @return public.eql_v3_real_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_real_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ope, selector integer) RETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_real_ord_ope ---! @return public.eql_v3_real_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator +--! @return public.eql_v3_real_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_ord_ope) RETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_real_ord_ope ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_real_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b public.eql_v3_real_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_real_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$ diff --git a/src/v3/scalars/real/real_ord_ope_operators.sql b/src/v3/scalars/real/real_ord_ope_operators.sql index 5e77ac591..c11db40a3 100644 --- a/src/v3/scalars/real/real_ord_ope_operators.sql +++ b/src/v3/scalars/real/real_ord_ope_operators.sql @@ -194,6 +194,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonpath diff --git a/src/v3/scalars/real/real_ord_operators.sql b/src/v3/scalars/real/real_ord_operators.sql index a5f7373e4..b5b3692b1 100644 --- a/src/v3/scalars/real/real_ord_operators.sql +++ b/src/v3/scalars/real/real_ord_operators.sql @@ -194,6 +194,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonpath diff --git a/src/v3/scalars/real/real_ord_ore_functions.sql b/src/v3/scalars/real/real_ord_ore_functions.sql index 240c5fd5e..bbc01055f 100644 --- a/src/v3/scalars/real/real_ord_ore_functions.sql +++ b/src/v3/scalars/real/real_ord_ore_functions.sql @@ -161,234 +161,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) >= eql_v3.ord_term_ore(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b public.eql_v3_real_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_real_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b public.eql_v3_real_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_real_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param selector text ---! @return public.eql_v3_real_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_real_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ore, selector text) RETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param selector integer ---! @return public.eql_v3_real_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_real_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ore, selector integer) RETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_real_ord_ore ---! @return public.eql_v3_real_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator +--! @return public.eql_v3_real_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_ord_ore) RETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_real_ord_ore ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_real_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b public.eql_v3_real_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_real_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$ diff --git a/src/v3/scalars/real/real_ord_ore_operators.sql b/src/v3/scalars/real/real_ord_ore_operators.sql index f8bcaaa12..bb5fb6d9e 100644 --- a/src/v3/scalars/real/real_ord_ore_operators.sql +++ b/src/v3/scalars/real/real_ord_ore_operators.sql @@ -194,6 +194,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonpath diff --git a/src/v3/scalars/smallint/smallint_eq_functions.sql b/src/v3/scalars/smallint/smallint_eq_functions.sql index 9e61b505c..3721f5af3 100644 --- a/src/v3/scalars/smallint/smallint_eq_functions.sql +++ b/src/v3/scalars/smallint/smallint_eq_functions.sql @@ -64,342 +64,574 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) <> eql_v3.eq_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a jsonb ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a jsonb ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a jsonb ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a jsonb ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a jsonb ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a jsonb ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param selector text ---! @return public.eql_v3_smallint_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_smallint_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_eq, selector text) RETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param selector integer ---! @return public.eql_v3_smallint_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_smallint_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_eq, selector integer) RETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a jsonb ---! @param selector public.eql_v3_smallint_eq ---! @return public.eql_v3_smallint_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator +--! @return public.eql_v3_smallint_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint_eq) RETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a jsonb ---! @param selector public.eql_v3_smallint_eq ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint_eq) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a jsonb ---! @param b public.eql_v3_smallint_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$ diff --git a/src/v3/scalars/smallint/smallint_eq_operators.sql b/src/v3/scalars/smallint/smallint_eq_operators.sql index 76d1a0201..d69ab9fa8 100644 --- a/src/v3/scalars/smallint/smallint_eq_operators.sql +++ b/src/v3/scalars/smallint/smallint_eq_operators.sql @@ -182,6 +182,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonpath diff --git a/src/v3/scalars/smallint/smallint_functions.sql b/src/v3/scalars/smallint/smallint_functions.sql index 18b2cd7a2..3423c9a39 100644 --- a/src/v3/scalars/smallint/smallint_functions.sql +++ b/src/v3/scalars/smallint/smallint_functions.sql @@ -7,396 +7,658 @@ --! @brief Functions for public.eql_v3_smallint. --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param selector text ---! @return public.eql_v3_smallint +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_smallint never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint, selector text) RETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param selector integer ---! @return public.eql_v3_smallint +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_smallint never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint, selector integer) RETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param selector public.eql_v3_smallint ---! @return public.eql_v3_smallint +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_smallint right operand of the blocked operator +--! @return public.eql_v3_smallint never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint) RETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param selector public.eql_v3_smallint ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_smallint right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint, b public.eql_v3_smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$ diff --git a/src/v3/scalars/smallint/smallint_operators.sql b/src/v3/scalars/smallint/smallint_operators.sql index 976c20275..b249a6835 100644 --- a/src/v3/scalars/smallint/smallint_operators.sql +++ b/src/v3/scalars/smallint/smallint_operators.sql @@ -176,6 +176,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonpath diff --git a/src/v3/scalars/smallint/smallint_ord_functions.sql b/src/v3/scalars/smallint/smallint_ord_functions.sql index e36b16365..705a8556c 100644 --- a/src/v3/scalars/smallint/smallint_ord_functions.sql +++ b/src/v3/scalars/smallint/smallint_ord_functions.sql @@ -160,234 +160,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b public.eql_v3_smallint_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a jsonb ---! @param b public.eql_v3_smallint_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b public.eql_v3_smallint_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a jsonb ---! @param b public.eql_v3_smallint_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param selector text ---! @return public.eql_v3_smallint_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_smallint_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_ord, selector text) RETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param selector integer ---! @return public.eql_v3_smallint_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_smallint_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_ord, selector integer) RETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a jsonb ---! @param selector public.eql_v3_smallint_ord ---! @return public.eql_v3_smallint_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator +--! @return public.eql_v3_smallint_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint_ord) RETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a jsonb ---! @param selector public.eql_v3_smallint_ord ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint_ord) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_smallint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b public.eql_v3_smallint_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a jsonb ---! @param b public.eql_v3_smallint_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$ diff --git a/src/v3/scalars/smallint/smallint_ord_ope_functions.sql b/src/v3/scalars/smallint/smallint_ord_ope_functions.sql index b7e267007..307f01c0f 100644 --- a/src/v3/scalars/smallint/smallint_ord_ope_functions.sql +++ b/src/v3/scalars/smallint/smallint_ord_ope_functions.sql @@ -160,234 +160,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_smallint_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_smallint_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param selector text ---! @return public.eql_v3_smallint_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_ord_ope, selector text) RETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param selector integer ---! @return public.eql_v3_smallint_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_ord_ope, selector integer) RETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_smallint_ord_ope ---! @return public.eql_v3_smallint_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint_ord_ope) RETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_smallint_ord_ope ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_smallint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_smallint_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$ diff --git a/src/v3/scalars/smallint/smallint_ord_ope_operators.sql b/src/v3/scalars/smallint/smallint_ord_ope_operators.sql index 045e7d4ed..3f45121ed 100644 --- a/src/v3/scalars/smallint/smallint_ord_ope_operators.sql +++ b/src/v3/scalars/smallint/smallint_ord_ope_operators.sql @@ -194,6 +194,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonpath diff --git a/src/v3/scalars/smallint/smallint_ord_operators.sql b/src/v3/scalars/smallint/smallint_ord_operators.sql index 7d8f45572..b5efb730c 100644 --- a/src/v3/scalars/smallint/smallint_ord_operators.sql +++ b/src/v3/scalars/smallint/smallint_ord_operators.sql @@ -194,6 +194,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonpath diff --git a/src/v3/scalars/smallint/smallint_ord_ore_functions.sql b/src/v3/scalars/smallint/smallint_ord_ore_functions.sql index e3f1a90d1..ae14169f0 100644 --- a/src/v3/scalars/smallint/smallint_ord_ore_functions.sql +++ b/src/v3/scalars/smallint/smallint_ord_ore_functions.sql @@ -161,234 +161,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) >= eql_v3.ord_term_ore(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b public.eql_v3_smallint_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_smallint_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b public.eql_v3_smallint_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_smallint_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param selector text ---! @return public.eql_v3_smallint_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_ord_ore, selector text) RETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param selector integer ---! @return public.eql_v3_smallint_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_ord_ore, selector integer) RETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_smallint_ord_ore ---! @return public.eql_v3_smallint_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint_ord_ore) RETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_smallint_ord_ore ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_smallint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b public.eql_v3_smallint_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_smallint_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$ diff --git a/src/v3/scalars/smallint/smallint_ord_ore_operators.sql b/src/v3/scalars/smallint/smallint_ord_ore_operators.sql index da77545ee..602a85417 100644 --- a/src/v3/scalars/smallint/smallint_ord_ore_operators.sql +++ b/src/v3/scalars/smallint/smallint_ord_ore_operators.sql @@ -194,6 +194,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonpath diff --git a/src/v3/scalars/text/query_text_match_functions.sql b/src/v3/scalars/text/query_text_match_functions.sql index e1b0bc73a..786ed9bdc 100644 --- a/src/v3/scalars/text/query_text_match_functions.sql +++ b/src/v3/scalars/text/query_text_match_functions.sql @@ -18,7 +18,7 @@ AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; --! @param a public.eql_v3_text_match --! @param b eql_v3.query_text_match --! @return boolean -CREATE FUNCTION eql_v3.contains(a public.eql_v3_text_match, b eql_v3.query_text_match) +CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b eql_v3.query_text_match) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; @@ -26,22 +26,6 @@ AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; --! @param a eql_v3.query_text_match --! @param b public.eql_v3_text_match --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.query_text_match, b public.eql_v3_text_match) +CREATE FUNCTION eql_v3.matches(a eql_v3.query_text_match, b public.eql_v3_text_match) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_match. ---! @param a public.eql_v3_text_match ---! @param b eql_v3.query_text_match ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_match, b eql_v3.query_text_match) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_match. ---! @param a eql_v3.query_text_match ---! @param b public.eql_v3_text_match ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.query_text_match, b public.eql_v3_text_match) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; diff --git a/src/v3/scalars/text/query_text_match_operators.sql b/src/v3/scalars/text/query_text_match_operators.sql index 5d0046a22..8a510552d 100644 --- a/src/v3/scalars/text/query_text_match_operators.sql +++ b/src/v3/scalars/text/query_text_match_operators.sql @@ -6,26 +6,14 @@ --! @file encrypted_domain/text/query_text_match_operators.sql --! @brief Operators for eql_v3.query_text_match. -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, LEFTARG = public.eql_v3_text_match, RIGHTARG = eql_v3.query_text_match, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel + RESTRICT = contsel, JOIN = contjoinsel ); -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, LEFTARG = eql_v3.query_text_match, RIGHTARG = public.eql_v3_text_match, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = public.eql_v3_text_match, RIGHTARG = eql_v3.query_text_match, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.query_text_match, RIGHTARG = public.eql_v3_text_match, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel + RESTRICT = contsel, JOIN = contjoinsel ); diff --git a/src/v3/scalars/text/query_text_search_functions.sql b/src/v3/scalars/text/query_text_search_functions.sql index ef6d32e1a..2ab6b8ec8 100644 --- a/src/v3/scalars/text/query_text_search_functions.sql +++ b/src/v3/scalars/text/query_text_search_functions.sql @@ -130,7 +130,7 @@ AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; --! @param a public.eql_v3_text_search --! @param b eql_v3.query_text_search --! @return boolean -CREATE FUNCTION eql_v3.contains(a public.eql_v3_text_search, b eql_v3.query_text_search) +CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b eql_v3.query_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; @@ -138,22 +138,6 @@ AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; --! @param a eql_v3.query_text_search --! @param b public.eql_v3_text_search --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.query_text_search, b public.eql_v3_text_search) +CREATE FUNCTION eql_v3.matches(a eql_v3.query_text_search, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a public.eql_v3_text_search ---! @param b eql_v3.query_text_search ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_search, b eql_v3.query_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a eql_v3.query_text_search ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.query_text_search, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; diff --git a/src/v3/scalars/text/query_text_search_operators.sql b/src/v3/scalars/text/query_text_search_operators.sql index 1f8de0b4e..6a5502c37 100644 --- a/src/v3/scalars/text/query_text_search_operators.sql +++ b/src/v3/scalars/text/query_text_search_operators.sql @@ -78,26 +78,14 @@ CREATE OPERATOR >= ( COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel + RESTRICT = contsel, JOIN = contjoinsel ); -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel + RESTRICT = contsel, JOIN = contjoinsel ); diff --git a/src/v3/scalars/text/query_text_search_ore_functions.sql b/src/v3/scalars/text/query_text_search_ore_functions.sql index e034d8d2f..adbf20a31 100644 --- a/src/v3/scalars/text/query_text_search_ore_functions.sql +++ b/src/v3/scalars/text/query_text_search_ore_functions.sql @@ -130,7 +130,7 @@ AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; --! @param a public.eql_v3_text_search_ore --! @param b eql_v3.query_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.contains(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) +CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; @@ -138,22 +138,6 @@ AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; --! @param a eql_v3.query_text_search_ore --! @param b public.eql_v3_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.contains(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) +CREATE FUNCTION eql_v3.matches(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b eql_v3.query_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; - ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a eql_v3.query_text_search_ore ---! @param b public.eql_v3_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; diff --git a/src/v3/scalars/text/query_text_search_ore_operators.sql b/src/v3/scalars/text/query_text_search_ore_operators.sql index c2f69ec98..0a78693fe 100644 --- a/src/v3/scalars/text/query_text_search_ore_operators.sql +++ b/src/v3/scalars/text/query_text_search_ore_operators.sql @@ -78,26 +78,14 @@ CREATE OPERATOR >= ( COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel + RESTRICT = contsel, JOIN = contjoinsel ); -CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel -); - -CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel + RESTRICT = contsel, JOIN = contjoinsel ); diff --git a/src/v3/scalars/text/query_text_types.sql b/src/v3/scalars/text/query_text_types.sql index 5f648a3c7..eec1a886e 100644 --- a/src/v3/scalars/text/query_text_types.sql +++ b/src/v3/scalars/text/query_text_types.sql @@ -48,7 +48,7 @@ BEGIN ); END IF; - COMMENT ON DOMAIN eql_v3.query_text_match IS 'EQL text query operand (containment)'; + COMMENT ON DOMAIN eql_v3.query_text_match IS 'EQL text query operand (matching)'; --! @brief Query-operand domain eql_v3.query_text_ord_ore (term-only; no `c`). IF NOT EXISTS ( @@ -129,7 +129,7 @@ BEGIN ); END IF; - COMMENT ON DOMAIN eql_v3.query_text_search_ore IS 'EQL text query operand (equality, ordering, containment)'; + COMMENT ON DOMAIN eql_v3.query_text_search_ore IS 'EQL text query operand (equality, ordering, matching)'; --! @brief Query-operand domain eql_v3.query_text_search (term-only; no `c`). IF NOT EXISTS ( @@ -149,6 +149,6 @@ BEGIN ); END IF; - COMMENT ON DOMAIN eql_v3.query_text_search IS 'EQL text query operand (equality, ordering, containment)'; + COMMENT ON DOMAIN eql_v3.query_text_search IS 'EQL text query operand (equality, ordering, matching)'; END $$; diff --git a/src/v3/scalars/text/text_eq_functions.sql b/src/v3/scalars/text/text_eq_functions.sql index 54f1eff25..2bdd95fcf 100644 --- a/src/v3/scalars/text/text_eq_functions.sql +++ b/src/v3/scalars/text/text_eq_functions.sql @@ -64,342 +64,574 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) <> eql_v3.eq_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a jsonb ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a jsonb ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a jsonb ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a jsonb ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a jsonb ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a jsonb ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param selector text ---! @return public.eql_v3_text_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_text_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_eq, selector text) RETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param selector integer ---! @return public.eql_v3_text_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_text_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_eq, selector integer) RETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a jsonb ---! @param selector public.eql_v3_text_eq ---! @return public.eql_v3_text_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_eq right operand of the blocked operator +--! @return public.eql_v3_text_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_eq) RETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a jsonb ---! @param selector public.eql_v3_text_eq ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_eq right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_eq) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_eq, b public.eql_v3_text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a jsonb ---! @param b public.eql_v3_text_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$ diff --git a/src/v3/scalars/text/text_eq_operators.sql b/src/v3/scalars/text/text_eq_operators.sql index 149571124..b58d0ade5 100644 --- a/src/v3/scalars/text/text_eq_operators.sql +++ b/src/v3/scalars/text/text_eq_operators.sql @@ -182,6 +182,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonpath diff --git a/src/v3/scalars/text/text_functions.sql b/src/v3/scalars/text/text_functions.sql index 1b13e8b6d..6a4e06dae 100644 --- a/src/v3/scalars/text/text_functions.sql +++ b/src/v3/scalars/text/text_functions.sql @@ -7,396 +7,658 @@ --! @brief Functions for public.eql_v3_text. --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a jsonb ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a jsonb ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a jsonb ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a jsonb ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a jsonb ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a jsonb ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a jsonb ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a jsonb ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param selector text ---! @return public.eql_v3_text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text, selector text) RETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param selector integer ---! @return public.eql_v3_text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text, selector integer) RETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a jsonb ---! @param selector public.eql_v3_text ---! @return public.eql_v3_text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text right operand of the blocked operator +--! @return public.eql_v3_text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text) RETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a jsonb ---! @param selector public.eql_v3_text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text. +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text, b public.eql_v3_text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a jsonb ---! @param b public.eql_v3_text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$ diff --git a/src/v3/scalars/text/text_match_functions.sql b/src/v3/scalars/text/text_match_functions.sql index f19a22801..04d74997a 100644 --- a/src/v3/scalars/text/text_match_functions.sql +++ b/src/v3/scalars/text/text_match_functions.sql @@ -16,390 +16,640 @@ LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a jsonb ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a jsonb ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a jsonb ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a jsonb ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a jsonb ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a jsonb ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match ---! @return boolean -CREATE FUNCTION eql_v3.contains(a public.eql_v3_text_match, b public.eql_v3_text_match) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_match, b public.eql_v3_text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.contains(a public.eql_v3_text_match, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_match) $$; +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_text_match. ---! @param a jsonb ---! @param b public.eql_v3_text_match ---! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b public.eql_v3_text_match) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_match) @> eql_v3.match_term(b) $$; +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_match, b public.eql_v3_text_match) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_match, b public.eql_v3_text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_match, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b::public.eql_v3_text_match) $$; +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_text_match. ---! @param a jsonb ---! @param b public.eql_v3_text_match ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b public.eql_v3_text_match) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_match) <@ eql_v3.match_term(b) $$; +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$ +LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param selector text ---! @return public.eql_v3_text_match +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_text_match never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_match, selector text) RETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param selector integer ---! @return public.eql_v3_text_match +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_text_match never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_match, selector integer) RETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a jsonb ---! @param selector public.eql_v3_text_match ---! @return public.eql_v3_text_match +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_match right operand of the blocked operator +--! @return public.eql_v3_text_match never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_match) RETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_match, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_match, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a jsonb ---! @param selector public.eql_v3_text_match ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_match right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_match) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_match, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_match, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_match, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_match, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Operator wrapper for public.eql_v3_text_match. --! @param a public.eql_v3_text_match ---! @param b jsonpath +--! @param b public.eql_v3_text_match +--! @return boolean +CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b public.eql_v3_text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_text_match. +--! @param a public.eql_v3_text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_match) $$; + +--! @brief Operator wrapper for public.eql_v3_text_match. +--! @param a jsonb +--! @param b public.eql_v3_text_match --! @return boolean +CREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_match) @> eql_v3.match_term(b) $$; + +--! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_match, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_match, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_match, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_match, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_match, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_match, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_match, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_match, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a jsonb ---! @param b public.eql_v3_text_match ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_match) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$ diff --git a/src/v3/scalars/text/text_match_operators.sql b/src/v3/scalars/text/text_match_operators.sql index 50a2fb896..8f8bae19c 100644 --- a/src/v3/scalars/text/text_match_operators.sql +++ b/src/v3/scalars/text/text_match_operators.sql @@ -97,39 +97,33 @@ CREATE OPERATOR >= ( ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match ); CREATE OPERATOR -> ( @@ -182,6 +176,24 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match, + RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb, + RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match, + RESTRICT = contsel, JOIN = contjoinsel +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonpath diff --git a/src/v3/scalars/text/text_operators.sql b/src/v3/scalars/text/text_operators.sql index 9ab94b2a4..73c967969 100644 --- a/src/v3/scalars/text/text_operators.sql +++ b/src/v3/scalars/text/text_operators.sql @@ -176,6 +176,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_text, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_text, RIGHTARG = jsonpath diff --git a/src/v3/scalars/text/text_ord_functions.sql b/src/v3/scalars/text/text_ord_functions.sql index 7bc554677..b8257790c 100644 --- a/src/v3/scalars/text/text_ord_functions.sql +++ b/src/v3/scalars/text/text_ord_functions.sql @@ -169,234 +169,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b public.eql_v3_text_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b public.eql_v3_text_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a jsonb ---! @param b public.eql_v3_text_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b public.eql_v3_text_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b public.eql_v3_text_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a jsonb ---! @param b public.eql_v3_text_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param selector text ---! @return public.eql_v3_text_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_text_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord, selector text) RETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param selector integer ---! @return public.eql_v3_text_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_text_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord, selector integer) RETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a jsonb ---! @param selector public.eql_v3_text_ord ---! @return public.eql_v3_text_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_ord right operand of the blocked operator +--! @return public.eql_v3_text_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_ord) RETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a jsonb ---! @param selector public.eql_v3_text_ord ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_ord right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_ord) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b public.eql_v3_text_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord, b public.eql_v3_text_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_text_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b public.eql_v3_text_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b public.eql_v3_text_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a jsonb ---! @param b public.eql_v3_text_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$ diff --git a/src/v3/scalars/text/text_ord_ope_functions.sql b/src/v3/scalars/text/text_ord_ope_functions.sql index 567f8dc64..a2b05930f 100644 --- a/src/v3/scalars/text/text_ord_ope_functions.sql +++ b/src/v3/scalars/text/text_ord_ope_functions.sql @@ -169,234 +169,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b public.eql_v3_text_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b public.eql_v3_text_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param selector text ---! @return public.eql_v3_text_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_text_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ope, selector text) RETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param selector integer ---! @return public.eql_v3_text_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_text_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ope, selector integer) RETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_text_ord_ope ---! @return public.eql_v3_text_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator +--! @return public.eql_v3_text_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_ord_ope) RETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_text_ord_ope ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_text_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b public.eql_v3_text_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$ diff --git a/src/v3/scalars/text/text_ord_ope_operators.sql b/src/v3/scalars/text/text_ord_ope_operators.sql index 092e6ed9d..90609b417 100644 --- a/src/v3/scalars/text/text_ord_ope_operators.sql +++ b/src/v3/scalars/text/text_ord_ope_operators.sql @@ -194,6 +194,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonpath diff --git a/src/v3/scalars/text/text_ord_operators.sql b/src/v3/scalars/text/text_ord_operators.sql index 61979f06b..bbfceaeec 100644 --- a/src/v3/scalars/text/text_ord_operators.sql +++ b/src/v3/scalars/text/text_ord_operators.sql @@ -194,6 +194,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonpath diff --git a/src/v3/scalars/text/text_ord_ore_functions.sql b/src/v3/scalars/text/text_ord_ore_functions.sql index def8dbe08..f0bae2ed9 100644 --- a/src/v3/scalars/text/text_ord_ore_functions.sql +++ b/src/v3/scalars/text/text_ord_ore_functions.sql @@ -170,234 +170,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) >= eql_v3.ord_term_ore(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param selector text ---! @return public.eql_v3_text_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_text_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ore, selector text) RETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param selector integer ---! @return public.eql_v3_text_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_text_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ore, selector integer) RETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_text_ord_ore ---! @return public.eql_v3_text_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator +--! @return public.eql_v3_text_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_ord_ore) RETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_text_ord_ore ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$ diff --git a/src/v3/scalars/text/text_ord_ore_operators.sql b/src/v3/scalars/text/text_ord_ore_operators.sql index 4e9f33a69..bead4d0c1 100644 --- a/src/v3/scalars/text/text_ord_ore_operators.sql +++ b/src/v3/scalars/text/text_ord_ore_operators.sql @@ -194,6 +194,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonpath diff --git a/src/v3/scalars/text/text_search_functions.sql b/src/v3/scalars/text/text_search_functions.sql index 85f25d69d..140ea4ac8 100644 --- a/src/v3/scalars/text/text_search_functions.sql +++ b/src/v3/scalars/text/text_search_functions.sql @@ -177,229 +177,389 @@ CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) >= eql_v3.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.contains(a public.eql_v3_text_search, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b public.eql_v3_text_search right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b public.eql_v3_text_search) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.contains(a public.eql_v3_text_search, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search) $$; +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a jsonb ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search) @> eql_v3.match_term(b) $$; +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_search right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_search, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b public.eql_v3_text_search right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b public.eql_v3_text_search) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_search, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b::public.eql_v3_text_search) $$; +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a jsonb ---! @param b public.eql_v3_text_search ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b public.eql_v3_text_search) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search) <@ eql_v3.match_term(b) $$; +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_search right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$ +LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param selector text ---! @return public.eql_v3_text_search +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_text_search never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search, selector text) RETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param selector integer ---! @return public.eql_v3_text_search +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_text_search never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search, selector integer) RETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a jsonb ---! @param selector public.eql_v3_text_search ---! @return public.eql_v3_text_search +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_search right operand of the blocked operator +--! @return public.eql_v3_text_search never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_search) RETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a jsonb ---! @param selector public.eql_v3_text_search ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_search right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_search) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_search, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_search, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_search, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_search, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @brief Operator wrapper for public.eql_v3_text_search. --! @param a public.eql_v3_text_search ---! @param b jsonpath +--! @param b public.eql_v3_text_search --! @return boolean +CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b public.eql_v3_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a public.eql_v3_text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search) $$; + +--! @brief Operator wrapper for public.eql_v3_text_search. +--! @param a jsonb +--! @param b public.eql_v3_text_search +--! @return boolean +CREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search) @> eql_v3.match_term(b) $$; + +--! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_search, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_search, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_search, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_search, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b public.eql_v3_text_search ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b public.eql_v3_text_search right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search, b public.eql_v3_text_search) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a jsonb ---! @param b public.eql_v3_text_search ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_search right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_search) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$ diff --git a/src/v3/scalars/text/text_search_operators.sql b/src/v3/scalars/text/text_search_operators.sql index d24a8e779..68181488c 100644 --- a/src/v3/scalars/text/text_search_operators.sql +++ b/src/v3/scalars/text/text_search_operators.sql @@ -115,39 +115,33 @@ CREATE OPERATOR >= ( ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search ); CREATE OPERATOR -> ( @@ -200,6 +194,24 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, + RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, + RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, + RESTRICT = contsel, JOIN = contjoinsel +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonpath diff --git a/src/v3/scalars/text/text_search_ore_functions.sql b/src/v3/scalars/text/text_search_ore_functions.sql index 960973343..5d1d28f32 100644 --- a/src/v3/scalars/text/text_search_ore_functions.sql +++ b/src/v3/scalars/text/text_search_ore_functions.sql @@ -178,229 +178,389 @@ CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) >= eql_v3.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b public.eql_v3_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.contains(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b public.eql_v3_text_search_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.contains(a public.eql_v3_text_search_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search_ore) $$; +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.contains(a jsonb, b public.eql_v3_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search_ore) @> eql_v3.match_term(b) $$; +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_search_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b public.eql_v3_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b public.eql_v3_text_search_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b jsonb ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_search_ore, b jsonb) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b::public.eql_v3_text_search_ore) $$; +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_search_ore ---! @return boolean -CREATE FUNCTION eql_v3.contained_by(a jsonb, b public.eql_v3_text_search_ore) -RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search_ore) <@ eql_v3.match_term(b) $$; +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_search_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$ +LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param selector text ---! @return public.eql_v3_text_search_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_text_search_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search_ore, selector text) RETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param selector integer ---! @return public.eql_v3_text_search_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_text_search_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search_ore, selector integer) RETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a jsonb ---! @param selector public.eql_v3_text_search_ore ---! @return public.eql_v3_text_search_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator +--! @return public.eql_v3_text_search_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_search_ore) RETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a jsonb ---! @param selector public.eql_v3_text_search_ore ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_search_ore) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_search_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_search_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_search_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_search_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @brief Operator wrapper for public.eql_v3_text_search_ore. --! @param a public.eql_v3_text_search_ore ---! @param b jsonpath +--! @param b public.eql_v3_text_search_ore --! @return boolean +CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a public.eql_v3_text_search_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search_ore) $$; + +--! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @param a jsonb +--! @param b public.eql_v3_text_search_ore +--! @return boolean +CREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_search_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search_ore) @> eql_v3.match_term(b) $$; + +--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_search_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_search_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_search_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_search_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b public.eql_v3_text_search_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b public.eql_v3_text_search_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_search_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_search_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_search_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$ diff --git a/src/v3/scalars/text/text_search_ore_operators.sql b/src/v3/scalars/text/text_search_ore_operators.sql index e7ba08124..b1980cc7d 100644 --- a/src/v3/scalars/text/text_search_ore_operators.sql +++ b/src/v3/scalars/text/text_search_ore_operators.sql @@ -115,39 +115,33 @@ CREATE OPERATOR >= ( ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, - COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore ); CREATE OPERATOR -> ( @@ -200,6 +194,24 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, + RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3.matches, + LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, + RESTRICT = contsel, JOIN = contjoinsel +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonpath diff --git a/src/v3/scalars/text/text_types.sql b/src/v3/scalars/text/text_types.sql index 8470e0bb1..28f2718bb 100644 --- a/src/v3/scalars/text/text_types.sql +++ b/src/v3/scalars/text/text_types.sql @@ -57,7 +57,7 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_text_match IS 'EQL encrypted text (containment)'; + COMMENT ON DOMAIN public.eql_v3_text_match IS 'EQL encrypted text (matching)'; --! @brief Encrypted domain public.eql_v3_text_ord_ore. IF NOT EXISTS ( @@ -138,7 +138,7 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_text_search_ore IS 'EQL encrypted text (equality, ordering, containment)'; + COMMENT ON DOMAIN public.eql_v3_text_search_ore IS 'EQL encrypted text (equality, ordering, matching)'; --! @brief Encrypted domain public.eql_v3_text_search. IF NOT EXISTS ( @@ -158,6 +158,6 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_text_search IS 'EQL encrypted text (equality, ordering, containment)'; + COMMENT ON DOMAIN public.eql_v3_text_search IS 'EQL encrypted text (equality, ordering, matching)'; END $$; diff --git a/src/v3/scalars/timestamp/timestamp_eq_functions.sql b/src/v3/scalars/timestamp/timestamp_eq_functions.sql index 0c93347bd..c5551cfc4 100644 --- a/src/v3/scalars/timestamp/timestamp_eq_functions.sql +++ b/src/v3/scalars/timestamp/timestamp_eq_functions.sql @@ -64,342 +64,574 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) <> eql_v3.eq_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param selector text ---! @return public.eql_v3_timestamp_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_timestamp_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_eq, selector text) RETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param selector integer ---! @return public.eql_v3_timestamp_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_timestamp_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_eq, selector integer) RETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a jsonb ---! @param selector public.eql_v3_timestamp_eq ---! @return public.eql_v3_timestamp_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return public.eql_v3_timestamp_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_eq) RETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a jsonb ---! @param selector public.eql_v3_timestamp_eq ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_eq) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$ diff --git a/src/v3/scalars/timestamp/timestamp_eq_operators.sql b/src/v3/scalars/timestamp/timestamp_eq_operators.sql index f8a1029d1..f9c344077 100644 --- a/src/v3/scalars/timestamp/timestamp_eq_operators.sql +++ b/src/v3/scalars/timestamp/timestamp_eq_operators.sql @@ -182,6 +182,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonpath diff --git a/src/v3/scalars/timestamp/timestamp_functions.sql b/src/v3/scalars/timestamp/timestamp_functions.sql index 1c368ee4c..032d60210 100644 --- a/src/v3/scalars/timestamp/timestamp_functions.sql +++ b/src/v3/scalars/timestamp/timestamp_functions.sql @@ -7,396 +7,658 @@ --! @brief Functions for public.eql_v3_timestamp. --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a jsonb ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a jsonb ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a jsonb ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a jsonb ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a jsonb ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a jsonb ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a jsonb ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a jsonb ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param selector text ---! @return public.eql_v3_timestamp +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_timestamp never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp, selector text) RETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param selector integer ---! @return public.eql_v3_timestamp +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_timestamp never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp, selector integer) RETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a jsonb ---! @param selector public.eql_v3_timestamp ---! @return public.eql_v3_timestamp +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_timestamp right operand of the blocked operator +--! @return public.eql_v3_timestamp never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp) RETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a jsonb ---! @param selector public.eql_v3_timestamp ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_timestamp right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp, b public.eql_v3_timestamp) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a jsonb ---! @param b public.eql_v3_timestamp ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$ diff --git a/src/v3/scalars/timestamp/timestamp_operators.sql b/src/v3/scalars/timestamp/timestamp_operators.sql index a163552c4..c634ecaa9 100644 --- a/src/v3/scalars/timestamp/timestamp_operators.sql +++ b/src/v3/scalars/timestamp/timestamp_operators.sql @@ -176,6 +176,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonpath diff --git a/src/v3/scalars/timestamp/timestamp_ord_functions.sql b/src/v3/scalars/timestamp/timestamp_ord_functions.sql index 19544d686..0835181df 100644 --- a/src/v3/scalars/timestamp/timestamp_ord_functions.sql +++ b/src/v3/scalars/timestamp/timestamp_ord_functions.sql @@ -160,234 +160,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b public.eql_v3_timestamp_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b public.eql_v3_timestamp_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param selector text ---! @return public.eql_v3_timestamp_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_timestamp_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord, selector text) RETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param selector integer ---! @return public.eql_v3_timestamp_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_timestamp_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord, selector integer) RETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a jsonb ---! @param selector public.eql_v3_timestamp_ord ---! @return public.eql_v3_timestamp_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator +--! @return public.eql_v3_timestamp_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_ord) RETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a jsonb ---! @param selector public.eql_v3_timestamp_ord ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_ord) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b public.eql_v3_timestamp_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$ diff --git a/src/v3/scalars/timestamp/timestamp_ord_ope_functions.sql b/src/v3/scalars/timestamp/timestamp_ord_ope_functions.sql index 5e6a8f8a1..fa9a58797 100644 --- a/src/v3/scalars/timestamp/timestamp_ord_ope_functions.sql +++ b/src/v3/scalars/timestamp/timestamp_ord_ope_functions.sql @@ -160,234 +160,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param selector text ---! @return public.eql_v3_timestamp_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ope, selector text) RETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param selector integer ---! @return public.eql_v3_timestamp_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ope, selector integer) RETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_timestamp_ord_ope ---! @return public.eql_v3_timestamp_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_ord_ope) RETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_timestamp_ord_ope ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_timestamp_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$ diff --git a/src/v3/scalars/timestamp/timestamp_ord_ope_operators.sql b/src/v3/scalars/timestamp/timestamp_ord_ope_operators.sql index ad01e3916..476e379c6 100644 --- a/src/v3/scalars/timestamp/timestamp_ord_ope_operators.sql +++ b/src/v3/scalars/timestamp/timestamp_ord_ope_operators.sql @@ -194,6 +194,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonpath diff --git a/src/v3/scalars/timestamp/timestamp_ord_operators.sql b/src/v3/scalars/timestamp/timestamp_ord_operators.sql index ff6c02487..0334ca561 100644 --- a/src/v3/scalars/timestamp/timestamp_ord_operators.sql +++ b/src/v3/scalars/timestamp/timestamp_ord_operators.sql @@ -194,6 +194,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonpath diff --git a/src/v3/scalars/timestamp/timestamp_ord_ore_functions.sql b/src/v3/scalars/timestamp/timestamp_ord_ore_functions.sql index e785fd25f..8eb73a1da 100644 --- a/src/v3/scalars/timestamp/timestamp_ord_ore_functions.sql +++ b/src/v3/scalars/timestamp/timestamp_ord_ore_functions.sql @@ -161,234 +161,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) >= eql_v3.ord_term_ore(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param selector text ---! @return public.eql_v3_timestamp_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ore, selector text) RETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param selector integer ---! @return public.eql_v3_timestamp_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ore, selector integer) RETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_timestamp_ord_ore ---! @return public.eql_v3_timestamp_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_ord_ore) RETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_timestamp_ord_ore ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$ diff --git a/src/v3/scalars/timestamp/timestamp_ord_ore_operators.sql b/src/v3/scalars/timestamp/timestamp_ord_ore_operators.sql index 50ba59478..b12b343af 100644 --- a/src/v3/scalars/timestamp/timestamp_ord_ore_operators.sql +++ b/src/v3/scalars/timestamp/timestamp_ord_ore_operators.sql @@ -194,6 +194,21 @@ CREATE OPERATOR @? ( LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonpath ); +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore +); + CREATE OPERATOR @@ ( FUNCTION = eql_v3_internal."@@", LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonpath diff --git a/src/v3/sem/bloom_filter/types.sql b/src/v3/sem/bloom_filter/types.sql index 32452b88a..c7b496d11 100644 --- a/src/v3/sem/bloom_filter/types.sql +++ b/src/v3/sem/bloom_filter/types.sql @@ -5,10 +5,17 @@ --! @brief Bloom-filter index term: a bit array stored as smallint[]. --! ---! Backs the `match` capability (`@>` / `<@`) on `eql_v3_internal.text_match`. The ---! filter is read from the `bf` field of an encrypted jsonb payload. Native ---! `smallint[]` array-containment (`@>`/`<@`) is inherited through the domain, ---! so this type needs no custom operators. +--! Backs the `matches` fuzzy-match capability (the public `@@` operator / +--! `eql_v3.matches`) on the text match/search domains. The filter is read from +--! the `bf` field of an encrypted jsonb payload. The match wrapper body reduces +--! to native `smallint[]` array-containment (`@>`) on this domain — inherited +--! through the base type — so a functional GIN index on `eql_v3.match_term(col)` +--! engages; this type itself needs no custom operators. --! +--! @note The public operator is `@@` (fuzzy bloom-token matching), NOT the +--! containment operators `@>`/`<@`: the match is a probabilistic, one-sided +--! n-gram token match, not containment (CIP-3517). `@>`/`<@` on the text match +--! domains now raise. Internally the `@@` wrapper still reduces to the base +--! type's `@>` for GIN indexability. --! @note Self-contained: references no eql_v2 symbol. CREATE DOMAIN eql_v3_internal.bloom_filter AS smallint[]; diff --git a/tasks/test/splinter.sh b/tasks/test/splinter.sh index bbc70260c..a88818821 100755 --- a/tasks/test/splinter.sh +++ b/tasks/test/splinter.sh @@ -64,9 +64,8 @@ cat > "$work_dir/allowlist.tsv" <<'ALLOW' # tasks/pin_search_path_v3.sql and do not surface here. function_search_path_mutable eql_v3 eq_term function HMAC equality term extractor for the public *_eq domains: returns eql_v3.hmac_256. Must inline so `eql_v3.eq_term(col)` folds into the calling query and matches the functional hash/btree index built on the same expression. SET search_path would disable SQL function inlining (see PostgreSQL inline_function). function_search_path_mutable eql_v3 ord_term_ore function ORE-block order term extractor for the public *_ord_ore domains: returns eql_v3_internal.ore_block_256 (carrying the main DEFAULT btree opclass). Used inside the inlinable comparison wrappers and as the functional-index expression USING btree (eql_v3.ord_term_ore(col)); must inline. One overload per *_ord_ore domain (public.eql_v3_integer_ord_ore, eql_v3.query_integer_ord_ore). -function_search_path_mutable eql_v3 match_term function Bloom-filter match term extractor for the public *_match domains: returns eql_v3.bloom_filter. Used inside the inlinable @>/<@ containment wrappers and as the functional-index expression USING gin (eql_v3.match_term(col)); must inline so the GIN index engages. SET search_path would disable SQL function inlining. -function_search_path_mutable eql_v3 contains function Containment (@>) comparison wrapper on the public *_match domains — the public function-form equivalent of @> (callable without the operator on Supabase/PostgREST); the CREATE OPERATOR also lives in eql_v3. Inlines to `match_term(a) @> match_term(b)`; must reach the functional GIN index on eql_v3.match_term(col) for bloom-filter match to engage Bitmap Index Scan. -function_search_path_mutable eql_v3 contained_by function Contained-by (<@) comparison wrapper on the public *_match domains — public function-form equivalent of <@. Same rationale as eql_v3.contains. +function_search_path_mutable eql_v3 match_term function Bloom-filter match term extractor for the public *_match domains: returns eql_v3.bloom_filter. Used inside the inlinable @@ fuzzy-match wrapper (eql_v3.matches) and as the functional-index expression USING gin (eql_v3.match_term(col)); must inline so the GIN index engages. SET search_path would disable SQL function inlining. +function_search_path_mutable eql_v3 matches function Bloom fuzzy-match (@@) comparison wrapper on the public *_match domains — the public function-form equivalent of @@ (callable without the operator on Supabase/PostgREST); the CREATE OPERATOR also lives in eql_v3. Inlines to `match_term(a) @> match_term(b)` (bloom array-containment on the extracted terms); must reach the functional GIN index on eql_v3.match_term(col) for bloom-filter match to engage Bitmap Index Scan. (Renamed from eql_v3.contains — CIP-3517; @>/<@ are containment, not the match, and now raise on the *_match domains.) function_search_path_mutable eql_v3 eq function Equality comparison wrapper on the public domains — the public function-form equivalent of = (callable without the operator). Inlines to `eq_term(a) = eq_term(b)`; must reach the functional index on eql_v3.eq_term(col) for bare-form equality to engage Index Scan. Covers the converged eq wrappers on the public scalar variants, and the jsonb_entry eq wrapper (jsonb/operators.sql) which shares the same (schema, name, type) key. function_search_path_mutable eql_v3 neq function Inequality comparison wrapper on the public domains — public function-form equivalent of <>. Same rationale as eql_v3.eq. function_search_path_mutable eql_v3 lt function Less-than comparison wrapper on the public ordered domains — public function-form equivalent of <. Inlines to `ord_term(a) < ord_term(b)`; must reach the functional btree index on eql_v3.ord_term(col) for range queries to engage Index Scan. Also covers the jsonb_entry lt wrapper (via ore_cllw), which shares the same (schema, name, type) key. diff --git a/tests/sqlx/snapshots/eql_v3_public_surface.txt b/tests/sqlx/snapshots/eql_v3_public_surface.txt index 13962cd2d..510e9a74e 100644 --- a/tests/sqlx/snapshots/eql_v3_public_surface.txt +++ b/tests/sqlx/snapshots/eql_v3_public_surface.txt @@ -70,36 +70,6 @@ function eql_v3.@>(a public.eql_v3_json_search, b eql_v3.query_json) function eql_v3.@>(a public.eql_v3_json_search, b public.eql_v3_json_entry) function eql_v3.@>(a public.eql_v3_json_search, b public.eql_v3_json_search) function eql_v3.ciphertext(val jsonb) -function eql_v3.contained_by(a eql_v3.query_text_match, b public.eql_v3_text_match) -function eql_v3.contained_by(a eql_v3.query_text_search, b public.eql_v3_text_search) -function eql_v3.contained_by(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) -function eql_v3.contained_by(a jsonb, b public.eql_v3_text_match) -function eql_v3.contained_by(a jsonb, b public.eql_v3_text_search) -function eql_v3.contained_by(a jsonb, b public.eql_v3_text_search_ore) -function eql_v3.contained_by(a public.eql_v3_text_match, b eql_v3.query_text_match) -function eql_v3.contained_by(a public.eql_v3_text_match, b jsonb) -function eql_v3.contained_by(a public.eql_v3_text_match, b public.eql_v3_text_match) -function eql_v3.contained_by(a public.eql_v3_text_search, b eql_v3.query_text_search) -function eql_v3.contained_by(a public.eql_v3_text_search, b jsonb) -function eql_v3.contained_by(a public.eql_v3_text_search, b public.eql_v3_text_search) -function eql_v3.contained_by(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) -function eql_v3.contained_by(a public.eql_v3_text_search_ore, b jsonb) -function eql_v3.contained_by(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) -function eql_v3.contains(a eql_v3.query_text_match, b public.eql_v3_text_match) -function eql_v3.contains(a eql_v3.query_text_search, b public.eql_v3_text_search) -function eql_v3.contains(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) -function eql_v3.contains(a jsonb, b public.eql_v3_text_match) -function eql_v3.contains(a jsonb, b public.eql_v3_text_search) -function eql_v3.contains(a jsonb, b public.eql_v3_text_search_ore) -function eql_v3.contains(a public.eql_v3_text_match, b eql_v3.query_text_match) -function eql_v3.contains(a public.eql_v3_text_match, b jsonb) -function eql_v3.contains(a public.eql_v3_text_match, b public.eql_v3_text_match) -function eql_v3.contains(a public.eql_v3_text_search, b eql_v3.query_text_search) -function eql_v3.contains(a public.eql_v3_text_search, b jsonb) -function eql_v3.contains(a public.eql_v3_text_search, b public.eql_v3_text_search) -function eql_v3.contains(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) -function eql_v3.contains(a public.eql_v3_text_search_ore, b jsonb) -function eql_v3.contains(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) function eql_v3.eq(a eql_v3.query_bigint_eq, b public.eql_v3_bigint_eq) function eql_v3.eq(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) function eql_v3.eq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) @@ -920,6 +890,21 @@ function eql_v3.match_term(a eql_v3.query_text_search_ore) function eql_v3.match_term(a public.eql_v3_text_match) function eql_v3.match_term(a public.eql_v3_text_search) function eql_v3.match_term(a public.eql_v3_text_search_ore) +function eql_v3.matches(a eql_v3.query_text_match, b public.eql_v3_text_match) +function eql_v3.matches(a eql_v3.query_text_search, b public.eql_v3_text_search) +function eql_v3.matches(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) +function eql_v3.matches(a jsonb, b public.eql_v3_text_match) +function eql_v3.matches(a jsonb, b public.eql_v3_text_search) +function eql_v3.matches(a jsonb, b public.eql_v3_text_search_ore) +function eql_v3.matches(a public.eql_v3_text_match, b eql_v3.query_text_match) +function eql_v3.matches(a public.eql_v3_text_match, b jsonb) +function eql_v3.matches(a public.eql_v3_text_match, b public.eql_v3_text_match) +function eql_v3.matches(a public.eql_v3_text_search, b eql_v3.query_text_search) +function eql_v3.matches(a public.eql_v3_text_search, b jsonb) +function eql_v3.matches(a public.eql_v3_text_search, b public.eql_v3_text_search) +function eql_v3.matches(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) +function eql_v3.matches(a public.eql_v3_text_search_ore, b jsonb) +function eql_v3.matches(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) function eql_v3.meta_data(val jsonb) function eql_v3.neq(a eql_v3.query_bigint_eq, b public.eql_v3_bigint_eq) function eql_v3.neq(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) diff --git a/tests/sqlx/snapshots/matrix_tests_text.txt b/tests/sqlx/snapshots/matrix_tests_text.txt index 7b3e58f4e..b61bf318e 100644 --- a/tests/sqlx/snapshots/matrix_tests_text.txt +++ b/tests/sqlx/snapshots/matrix_tests_text.txt @@ -254,10 +254,10 @@ scalars::::matrix__search_lte_pivot_mid_cross_shape scalars::::matrix__search_lte_pivot_min_correctness scalars::::matrix__search_lte_pivot_min_cross_shape scalars::::matrix__search_lte_supported_null -scalars::::matrix__search_match_contains_needle -scalars::::matrix__search_match_contains_self scalars::::matrix__search_match_disjoint_miss scalars::::matrix__search_match_index_engages_gin +scalars::::matrix__search_match_needle +scalars::::matrix__search_match_self scalars::::matrix__search_native_absent_ops scalars::::matrix__search_native_jsonb_blockers scalars::::matrix__search_neq_pivot_max_correctness @@ -333,10 +333,10 @@ scalars::::matrix__search_ore_lte_pivot_mid_cross_shape scalars::::matrix__search_ore_lte_pivot_min_correctness scalars::::matrix__search_ore_lte_pivot_min_cross_shape scalars::::matrix__search_ore_lte_supported_null -scalars::::matrix__search_ore_match_contains_needle -scalars::::matrix__search_ore_match_contains_self scalars::::matrix__search_ore_match_disjoint_miss scalars::::matrix__search_ore_match_index_engages_gin +scalars::::matrix__search_ore_match_needle +scalars::::matrix__search_ore_match_self scalars::::matrix__search_ore_native_absent_ops scalars::::matrix__search_ore_native_jsonb_blockers scalars::::matrix__search_ore_neq_pivot_max_correctness diff --git a/tests/sqlx/snapshots/text_expanded.rs b/tests/sqlx/snapshots/text_expanded.rs index 37e83d5bd..b6e67bd6f 100644 --- a/tests/sqlx/snapshots/text_expanded.rs +++ b/tests/sqlx/snapshots/text_expanded.rs @@ -35971,20 +35971,18 @@ pub mod text { ::sqlx::testing::TestFn::run_test(f, args) } extern crate test; - #[rustc_test_marker = "scalars::text::matrix_text_search_match_contains_self"] + #[rustc_test_marker = "scalars::text::matrix_text_search_match_self"] #[doc(hidden)] - pub const matrix_text_search_match_contains_self: test::TestDescAndFn = test::TestDescAndFn { + pub const matrix_text_search_match_self: test::TestDescAndFn = test::TestDescAndFn { desc: test::TestDesc { - name: test::StaticTestName( - "scalars::text::matrix_text_search_match_contains_self", - ), + name: test::StaticTestName("scalars::text::matrix_text_search_match_self"), ignore: false, ignore_message: ::core::option::Option::None, source_file: "tests/sqlx/src/matrix.rs", start_line: 2258usize, start_col: 22usize, end_line: 2258usize, - end_col: 73usize, + end_col: 64usize, compile_fail: false, no_run: false, should_panic: test::ShouldPanic::No, @@ -35992,11 +35990,11 @@ pub mod text { }, testfn: test::StaticTestFn( #[coverage(off)] - || test::assert_test_result(matrix_text_search_match_contains_self()), + || test::assert_test_result(matrix_text_search_match_self()), ), }; - fn matrix_text_search_match_contains_self() -> anyhow::Result<()> { - async fn matrix_text_search_match_contains_self( + fn matrix_text_search_match_self() -> anyhow::Result<()> { + async fn matrix_text_search_match_self( pool: sqlx::PgPool, ) -> anyhow::Result<()> { { @@ -36013,7 +36011,7 @@ pub mod text { &::alloc::__export::must_use({ ::alloc::fmt::format( format_args!( - "SELECT ($1::jsonb::{0}) @> ($1::jsonb::{0})", + "SELECT ($1::jsonb::{0}) @@ ($1::jsonb::{0})", d, ), ) @@ -36026,7 +36024,7 @@ pub mod text { return ::anyhow::__private::Err({ let error = ::anyhow::__private::format_err( format_args!( - "{0}: a value\'s bloom filter must contain itself", + "{0}: a value\'s bloom filter must match itself", d, ), ); @@ -36037,7 +36035,7 @@ pub mod text { } } let mut args = ::sqlx::testing::TestArgs::new( - "encrypted_domain::scalars::text::matrix_text_search_match_contains_self", + "encrypted_domain::scalars::text::matrix_text_search_match_self", ); args.migrator( &::sqlx::migrate::Migrator { @@ -36073,24 +36071,22 @@ pub mod text { }, ], ); - let f: fn(_) -> _ = matrix_text_search_match_contains_self; + let f: fn(_) -> _ = matrix_text_search_match_self; ::sqlx::testing::TestFn::run_test(f, args) } extern crate test; - #[rustc_test_marker = "scalars::text::matrix_text_search_match_contains_needle"] + #[rustc_test_marker = "scalars::text::matrix_text_search_match_needle"] #[doc(hidden)] - pub const matrix_text_search_match_contains_needle: test::TestDescAndFn = test::TestDescAndFn { + pub const matrix_text_search_match_needle: test::TestDescAndFn = test::TestDescAndFn { desc: test::TestDesc { - name: test::StaticTestName( - "scalars::text::matrix_text_search_match_contains_needle", - ), + name: test::StaticTestName("scalars::text::matrix_text_search_match_needle"), ignore: false, ignore_message: ::core::option::Option::None, source_file: "tests/sqlx/src/matrix.rs", start_line: 2274usize, start_col: 22usize, end_line: 2274usize, - end_col: 75usize, + end_col: 66usize, compile_fail: false, no_run: false, should_panic: test::ShouldPanic::No, @@ -36098,11 +36094,11 @@ pub mod text { }, testfn: test::StaticTestFn( #[coverage(off)] - || test::assert_test_result(matrix_text_search_match_contains_needle()), + || test::assert_test_result(matrix_text_search_match_needle()), ), }; - fn matrix_text_search_match_contains_needle() -> anyhow::Result<()> { - async fn matrix_text_search_match_contains_needle( + fn matrix_text_search_match_needle() -> anyhow::Result<()> { + async fn matrix_text_search_match_needle( pool: sqlx::PgPool, ) -> anyhow::Result<()> { { @@ -36123,7 +36119,7 @@ pub mod text { &::alloc::__export::must_use({ ::alloc::fmt::format( format_args!( - "SELECT ($1::jsonb::{0}) @> ($2::jsonb::{0})", + "SELECT ($1::jsonb::{0}) @@ ($2::jsonb::{0})", d, ), ) @@ -36137,7 +36133,7 @@ pub mod text { return ::anyhow::__private::Err({ let error = ::anyhow::__private::format_err( format_args!( - "{0}: haystack bloom must contain its shared-ngram needle", + "{0}: haystack bloom must match its shared-ngram needle", d, ), ); @@ -36148,7 +36144,7 @@ pub mod text { } } let mut args = ::sqlx::testing::TestArgs::new( - "encrypted_domain::scalars::text::matrix_text_search_match_contains_needle", + "encrypted_domain::scalars::text::matrix_text_search_match_needle", ); args.migrator( &::sqlx::migrate::Migrator { @@ -36184,7 +36180,7 @@ pub mod text { }, ], ); - let f: fn(_) -> _ = matrix_text_search_match_contains_needle; + let f: fn(_) -> _ = matrix_text_search_match_needle; ::sqlx::testing::TestFn::run_test(f, args) } extern crate test; @@ -36234,7 +36230,7 @@ pub mod text { &::alloc::__export::must_use({ ::alloc::fmt::format( format_args!( - "SELECT ($1::jsonb::{0}) @> ($2::jsonb::{0})", + "SELECT ($1::jsonb::{0}) @@ ($2::jsonb::{0})", d, ), ) @@ -36248,7 +36244,7 @@ pub mod text { return ::anyhow::__private::Err({ let error = ::anyhow::__private::format_err( format_args!( - "{0}: needle bloom must NOT contain an ngram-disjoint value", + "{0}: needle bloom must NOT match an ngram-disjoint value", d, ), ); @@ -36395,7 +36391,7 @@ pub mod text { &::alloc::__export::must_use({ ::alloc::fmt::format( format_args!( - "SELECT * FROM {0} WHERE value @> \'{1}\'::jsonb::{2}", + "SELECT * FROM {0} WHERE value @@ \'{1}\'::jsonb::{2}", table, lit, d, @@ -36403,7 +36399,7 @@ pub mod text { ) }), index, - "bare @> must engage the eql_v3.match_term functional GIN index", + "bare @@ must engage the eql_v3.match_term functional GIN index", ) .await?; tx.commit().await?; @@ -36451,12 +36447,12 @@ pub mod text { ::sqlx::testing::TestFn::run_test(f, args) } extern crate test; - #[rustc_test_marker = "scalars::text::matrix_text_search_ore_match_contains_self"] + #[rustc_test_marker = "scalars::text::matrix_text_search_ore_match_self"] #[doc(hidden)] - pub const matrix_text_search_ore_match_contains_self: test::TestDescAndFn = test::TestDescAndFn { + pub const matrix_text_search_ore_match_self: test::TestDescAndFn = test::TestDescAndFn { desc: test::TestDesc { name: test::StaticTestName( - "scalars::text::matrix_text_search_ore_match_contains_self", + "scalars::text::matrix_text_search_ore_match_self", ), ignore: false, ignore_message: ::core::option::Option::None, @@ -36464,7 +36460,7 @@ pub mod text { start_line: 2258usize, start_col: 22usize, end_line: 2258usize, - end_col: 73usize, + end_col: 64usize, compile_fail: false, no_run: false, should_panic: test::ShouldPanic::No, @@ -36472,11 +36468,11 @@ pub mod text { }, testfn: test::StaticTestFn( #[coverage(off)] - || test::assert_test_result(matrix_text_search_ore_match_contains_self()), + || test::assert_test_result(matrix_text_search_ore_match_self()), ), }; - fn matrix_text_search_ore_match_contains_self() -> anyhow::Result<()> { - async fn matrix_text_search_ore_match_contains_self( + fn matrix_text_search_ore_match_self() -> anyhow::Result<()> { + async fn matrix_text_search_ore_match_self( pool: sqlx::PgPool, ) -> anyhow::Result<()> { { @@ -36493,7 +36489,7 @@ pub mod text { &::alloc::__export::must_use({ ::alloc::fmt::format( format_args!( - "SELECT ($1::jsonb::{0}) @> ($1::jsonb::{0})", + "SELECT ($1::jsonb::{0}) @@ ($1::jsonb::{0})", d, ), ) @@ -36506,7 +36502,7 @@ pub mod text { return ::anyhow::__private::Err({ let error = ::anyhow::__private::format_err( format_args!( - "{0}: a value\'s bloom filter must contain itself", + "{0}: a value\'s bloom filter must match itself", d, ), ); @@ -36517,7 +36513,7 @@ pub mod text { } } let mut args = ::sqlx::testing::TestArgs::new( - "encrypted_domain::scalars::text::matrix_text_search_ore_match_contains_self", + "encrypted_domain::scalars::text::matrix_text_search_ore_match_self", ); args.migrator( &::sqlx::migrate::Migrator { @@ -36553,16 +36549,16 @@ pub mod text { }, ], ); - let f: fn(_) -> _ = matrix_text_search_ore_match_contains_self; + let f: fn(_) -> _ = matrix_text_search_ore_match_self; ::sqlx::testing::TestFn::run_test(f, args) } extern crate test; - #[rustc_test_marker = "scalars::text::matrix_text_search_ore_match_contains_needle"] + #[rustc_test_marker = "scalars::text::matrix_text_search_ore_match_needle"] #[doc(hidden)] - pub const matrix_text_search_ore_match_contains_needle: test::TestDescAndFn = test::TestDescAndFn { + pub const matrix_text_search_ore_match_needle: test::TestDescAndFn = test::TestDescAndFn { desc: test::TestDesc { name: test::StaticTestName( - "scalars::text::matrix_text_search_ore_match_contains_needle", + "scalars::text::matrix_text_search_ore_match_needle", ), ignore: false, ignore_message: ::core::option::Option::None, @@ -36570,7 +36566,7 @@ pub mod text { start_line: 2274usize, start_col: 22usize, end_line: 2274usize, - end_col: 75usize, + end_col: 66usize, compile_fail: false, no_run: false, should_panic: test::ShouldPanic::No, @@ -36578,11 +36574,11 @@ pub mod text { }, testfn: test::StaticTestFn( #[coverage(off)] - || test::assert_test_result(matrix_text_search_ore_match_contains_needle()), + || test::assert_test_result(matrix_text_search_ore_match_needle()), ), }; - fn matrix_text_search_ore_match_contains_needle() -> anyhow::Result<()> { - async fn matrix_text_search_ore_match_contains_needle( + fn matrix_text_search_ore_match_needle() -> anyhow::Result<()> { + async fn matrix_text_search_ore_match_needle( pool: sqlx::PgPool, ) -> anyhow::Result<()> { { @@ -36603,7 +36599,7 @@ pub mod text { &::alloc::__export::must_use({ ::alloc::fmt::format( format_args!( - "SELECT ($1::jsonb::{0}) @> ($2::jsonb::{0})", + "SELECT ($1::jsonb::{0}) @@ ($2::jsonb::{0})", d, ), ) @@ -36617,7 +36613,7 @@ pub mod text { return ::anyhow::__private::Err({ let error = ::anyhow::__private::format_err( format_args!( - "{0}: haystack bloom must contain its shared-ngram needle", + "{0}: haystack bloom must match its shared-ngram needle", d, ), ); @@ -36628,7 +36624,7 @@ pub mod text { } } let mut args = ::sqlx::testing::TestArgs::new( - "encrypted_domain::scalars::text::matrix_text_search_ore_match_contains_needle", + "encrypted_domain::scalars::text::matrix_text_search_ore_match_needle", ); args.migrator( &::sqlx::migrate::Migrator { @@ -36664,7 +36660,7 @@ pub mod text { }, ], ); - let f: fn(_) -> _ = matrix_text_search_ore_match_contains_needle; + let f: fn(_) -> _ = matrix_text_search_ore_match_needle; ::sqlx::testing::TestFn::run_test(f, args) } extern crate test; @@ -36714,7 +36710,7 @@ pub mod text { &::alloc::__export::must_use({ ::alloc::fmt::format( format_args!( - "SELECT ($1::jsonb::{0}) @> ($2::jsonb::{0})", + "SELECT ($1::jsonb::{0}) @@ ($2::jsonb::{0})", d, ), ) @@ -36728,7 +36724,7 @@ pub mod text { return ::anyhow::__private::Err({ let error = ::anyhow::__private::format_err( format_args!( - "{0}: needle bloom must NOT contain an ngram-disjoint value", + "{0}: needle bloom must NOT match an ngram-disjoint value", d, ), ); @@ -36875,7 +36871,7 @@ pub mod text { &::alloc::__export::must_use({ ::alloc::fmt::format( format_args!( - "SELECT * FROM {0} WHERE value @> \'{1}\'::jsonb::{2}", + "SELECT * FROM {0} WHERE value @@ \'{1}\'::jsonb::{2}", table, lit, d, @@ -36883,7 +36879,7 @@ pub mod text { ) }), index, - "bare @> must engage the eql_v3.match_term functional GIN index", + "bare @@ must engage the eql_v3.match_term functional GIN index", ) .await?; tx.commit().await?; diff --git a/tests/sqlx/src/matrix.rs b/tests/sqlx/src/matrix.rs index aec851ca2..a70c6c378 100644 --- a/tests/sqlx/src/matrix.rs +++ b/tests/sqlx/src/matrix.rs @@ -2255,7 +2255,7 @@ macro_rules! __scalar_matrix_match_case { ) => { $crate::paste::paste! { #[sqlx::test(fixtures(path = $script_path, scripts($script)))] - async fn []( + async fn []( pool: sqlx::PgPool, ) -> anyhow::Result<()> { use $crate::scalar_domains::MatchScalar; @@ -2264,14 +2264,14 @@ macro_rules! __scalar_matrix_match_case { let hay = $crate::scalar_domains::fetch_fixture_payload::<$scalar>( &pool, <$scalar as MatchScalar>::haystack()).await?; let hit: bool = sqlx::query_scalar(&format!( - "SELECT ($1::jsonb::{d}) @> ($1::jsonb::{d})", + "SELECT ($1::jsonb::{d}) @@ ($1::jsonb::{d})", )).bind(&hay).fetch_one(&pool).await?; - anyhow::ensure!(hit, "{d}: a value's bloom filter must contain itself"); + anyhow::ensure!(hit, "{d}: a value's bloom filter must match itself"); Ok(()) } #[sqlx::test(fixtures(path = $script_path, scripts($script)))] - async fn []( + async fn []( pool: sqlx::PgPool, ) -> anyhow::Result<()> { use $crate::scalar_domains::MatchScalar; @@ -2282,10 +2282,10 @@ macro_rules! __scalar_matrix_match_case { let needle = $crate::scalar_domains::fetch_fixture_payload::<$scalar>( &pool, <$scalar as MatchScalar>::needle()).await?; let hit: bool = sqlx::query_scalar(&format!( - "SELECT ($1::jsonb::{d}) @> ($2::jsonb::{d})", + "SELECT ($1::jsonb::{d}) @@ ($2::jsonb::{d})", )).bind(&hay).bind(&needle).fetch_one(&pool).await?; anyhow::ensure!(hit, - "{d}: haystack bloom must contain its shared-ngram needle"); + "{d}: haystack bloom must match its shared-ngram needle"); Ok(()) } @@ -2301,16 +2301,16 @@ macro_rules! __scalar_matrix_match_case { let disjoint = $crate::scalar_domains::fetch_fixture_payload::<$scalar>( &pool, <$scalar as MatchScalar>::disjoint()).await?; let hit: bool = sqlx::query_scalar(&format!( - "SELECT ($1::jsonb::{d}) @> ($2::jsonb::{d})", + "SELECT ($1::jsonb::{d}) @@ ($2::jsonb::{d})", )).bind(&needle).bind(&disjoint).fetch_one(&pool).await?; anyhow::ensure!(!hit, - "{d}: needle bloom must NOT contain an ngram-disjoint value"); + "{d}: needle bloom must NOT match an ngram-disjoint value"); Ok(()) } // VALIDITY, NOT PREFERENCE: `enable_seqscan = off` on the small // fixture forces the planner onto the only usable alternative. A - // green assertion proves the bare `@>` operator inlines through + // green assertion proves the bare `@@` operator inlines through // `match_term` to the native array containment the GIN index // supports — NOT that the planner would prefer it at scale. The // assertion is node-type-aware (a genuine Bitmap/Index Scan node @@ -2351,9 +2351,9 @@ macro_rules! __scalar_matrix_match_case { let lit = needle.replace('\'', "''"); $crate::matrix::assert_index_scan_uses( &mut *tx, - &format!("SELECT * FROM {table} WHERE value @> '{lit}'::jsonb::{d}"), + &format!("SELECT * FROM {table} WHERE value @@ '{lit}'::jsonb::{d}"), index, - "bare @> must engage the eql_v3.match_term functional GIN index", + "bare @@ must engage the eql_v3.match_term functional GIN index", ).await?; tx.commit().await?; diff --git a/tests/sqlx/src/property.rs b/tests/sqlx/src/property.rs index 0bb445384..e91af74b9 100644 --- a/tests/sqlx/src/property.rs +++ b/tests/sqlx/src/property.rs @@ -550,11 +550,12 @@ pub async fn assert_extractor_oracle( Ok(()) } -/// Bloom-filter **match** smoke (text only, example-based). Bloom containment +/// Bloom-filter **match** smoke (text only, example-based). Bloom matching /// admits false positives and the plaintext oracle is substring, not equality, /// so this is curated rather than a random property: three fixtures with known /// n-gram relationships (`haystack` ⊇ `needle`, `disjoint` shares none). Asserts -/// `eql_v3.contains` / `contained_by` respect **left-contains-right** `@>` and +/// `eql_v3.matches` (the `@@` fuzzy match, CIP-3517) respects +/// **left-matches-right** (`match_term(a) @> match_term(b)`, a's bloom ⊇ b's) and /// that `match_term` yields a non-empty `bf` array. Operands are the payload /// JSON literals cast to `domain` (`public.eql_v3_text_match`). pub async fn assert_match_smoke( @@ -568,62 +569,43 @@ pub async fn assert_match_smoke( let needle = cast(needle_json, domain); let disjoint = cast(disjoint_json, domain); // CIP-3432: the term-only query operands (bloom `bf`, no ciphertext `c`), - // consumed by the `(text_match, query_text_match)` containment operators. + // consumed by the `(text_match, query_text_match)` match operators. let needle_q = query_cast(needle_json, domain); let disjoint_q = query_cast(disjoint_json, domain); - // `contains(a, b)` = `match_term(a) @> match_term(b)` (a's bits ⊇ b's); - // `contained_by` is its mirror. Each row: (label, sql, expected). The last - // four rows drive the same containment through a term-only query operand. - let cases: [(&str, String, bool); 10] = [ + // `matches(a, b)` = `match_term(a) @> match_term(b)` (a's bloom ⊇ b's) — a + // single directional operator (no `contained_by` reverse). Each row: (label, + // sql, expected). The last three rows drive the same match through a term-only + // query operand, exercising both `(storage, query)` and `(query, storage)`. + let cases: [(&str, String, bool); 6] = [ ( - "contains(haystack, needle)", - format!("eql_v3.contains({haystack}, {needle})"), + "matches(haystack, needle)", + format!("eql_v3.matches({haystack}, {needle})"), true, ), ( - "contains(needle, haystack)", - format!("eql_v3.contains({needle}, {haystack})"), + "matches(needle, haystack)", + format!("eql_v3.matches({needle}, {haystack})"), false, ), ( - "contains(haystack, disjoint)", - format!("eql_v3.contains({haystack}, {disjoint})"), + "matches(haystack, disjoint)", + format!("eql_v3.matches({haystack}, {disjoint})"), false, ), ( - "contained_by(needle, haystack)", - format!("eql_v3.contained_by({needle}, {haystack})"), + "matches(haystack, needle_query) [CIP-3432]", + format!("eql_v3.matches({haystack}, {needle_q})"), true, ), ( - "contained_by(haystack, needle)", - format!("eql_v3.contained_by({haystack}, {needle})"), + "matches(haystack, disjoint_query) [CIP-3432]", + format!("eql_v3.matches({haystack}, {disjoint_q})"), false, ), ( - "contained_by(disjoint, haystack)", - format!("eql_v3.contained_by({disjoint}, {haystack})"), - false, - ), - ( - "contains(haystack, needle_query) [CIP-3432]", - format!("eql_v3.contains({haystack}, {needle_q})"), - true, - ), - ( - "contains(haystack, disjoint_query) [CIP-3432]", - format!("eql_v3.contains({haystack}, {disjoint_q})"), - false, - ), - ( - "contained_by(needle_query, haystack) [CIP-3432]", - format!("eql_v3.contained_by({needle_q}, {haystack})"), - true, - ), - ( - "contained_by(disjoint_query, haystack) [CIP-3432]", - format!("eql_v3.contained_by({disjoint_q}, {haystack})"), + "matches(needle_query, haystack) [CIP-3432]", + format!("eql_v3.matches({needle_q}, {haystack})"), false, ), ]; diff --git a/tests/sqlx/src/scalar_domains.rs b/tests/sqlx/src/scalar_domains.rs index f1bdc4576..0d3c4c84f 100644 --- a/tests/sqlx/src/scalar_domains.rs +++ b/tests/sqlx/src/scalar_domains.rs @@ -295,11 +295,11 @@ pub trait SignedScalar: OrderedScalar { fn origin() -> Self; } -/// A scalar with a **bloom-filter match** capability (`@>`/`<@` containment) — -/// currently only `text`, the one kind that declares a `Bloom`-bearing domain -/// (`_match`/`_search`). Provides three fixture plaintexts with known -/// containment relationships so the generated match arms can assert true hits -/// and a deterministic miss. The bound gates the match arms: a non-match scalar +/// A scalar with a **bloom-filter match** capability (the `@@` fuzzy match / +/// `eql_v3.matches`, CIP-3517) — currently only `text`, the one kind that +/// declares a `Bloom`-bearing domain (`_match`/`_search`). Provides three fixture +/// plaintexts with known n-gram relationships so the generated match arms can +/// assert true hits and a deterministic miss. The bound gates the match arms: a non-match scalar /// never declares `_search`, so the `caps = [eq, ord, search]` matrix arm (the /// only one emitting match cases) is never instantiated for it. pub trait MatchScalar: ScalarType { @@ -312,7 +312,7 @@ pub trait MatchScalar: ScalarType { fn needle() -> Self; /// A plaintext n-gram-**disjoint** from [`needle`](Self::needle), so - /// `needle @> disjoint` is a deterministic miss (a bloom filter only admits + /// `needle @@ disjoint` is a deterministic miss (a bloom filter only admits /// false positives, never false negatives). Present verbatim in /// `fixture_values()`. fn disjoint() -> Self; @@ -629,7 +629,7 @@ impl MatchScalar for String { } /// `"zzzz"` — 3-gram-disjoint from `"aard"` (`zzz` vs `aar`/`ard`), so - /// `aard @> zzzz` is a deterministic miss. Kept disjoint in `TEXT_FIXTURES` + /// `aard @@ zzzz` is a deterministic miss. Kept disjoint in `TEXT_FIXTURES` /// precisely for this assertion. fn disjoint() -> Self { "zzzz".to_string() diff --git a/tests/sqlx/tests/encrypted_domain/property/match_smoke.rs b/tests/sqlx/tests/encrypted_domain/property/match_smoke.rs index 31f3c807a..a4d6252a6 100644 --- a/tests/sqlx/tests/encrypted_domain/property/match_smoke.rs +++ b/tests/sqlx/tests/encrypted_domain/property/match_smoke.rs @@ -1,9 +1,9 @@ //! fixture-suite (CIP-3141) bloom-filter **match** smoke for the text `_match` //! domain. //! -//! Unlike the eq/ord oracles, bloom containment is not a random property: -//! `@>`/`<@` admit false positives and the plaintext oracle is *substring*, not -//! equality. So this is an example-based smoke over three curated fixtures with +//! Unlike the eq/ord oracles, bloom matching is not a random property: `@@` +//! (`eql_v3.matches`) admits false positives and the plaintext oracle is +//! *substring*, not equality. So this is an example-based smoke over three curated fixtures with //! known n-gram relationships — `"aardvark"` ⊇ `"aard"`, `"zzzz"` disjoint from //! both — pinned by the `MatchScalar` trait and the //! `text_match_pivots_are_in_fixture_values` guard. @@ -21,7 +21,7 @@ use eql_tests::property::assert_match_smoke; use eql_tests::scalar_domains::{fetch_fixture_payload, MatchScalar}; use sqlx::PgPool; -/// `public.eql_v3_text_match` — the bloom-filter (`bf`) domain (`@>`/`<@`). +/// `public.eql_v3_text_match` — the bloom-filter (`bf`) domain (`@@` fuzzy match). const TEXT_MATCH_DOMAIN: &str = "public.eql_v3_text_match"; #[sqlx::test] diff --git a/tests/sqlx/tests/encrypted_domain/text/text_match.rs b/tests/sqlx/tests/encrypted_domain/text/text_match.rs index aac31d5f5..db4c38283 100644 --- a/tests/sqlx/tests/encrypted_domain/text/text_match.rs +++ b/tests/sqlx/tests/encrypted_domain/text/text_match.rs @@ -1,6 +1,10 @@ -//! Match-containment coverage for `public.eql_v3_text_match` — separate from the -//! ordered matrix because `@>` is asymmetric/probabilistic, not a total order. -//! Asserts against the generated `eql_v3_text` fixtures (which carry `bf`). +//! Fuzzy-match coverage for `public.eql_v3_text_match` — separate from the +//! ordered matrix because `@@` is asymmetric/probabilistic, not a total order. +//! `@@` (`eql_v3.matches`) is bloom n-gram token matching, NOT containment +//! (CIP-3517): `col @@ needle` reduces to `match_term(col) @> match_term(needle)` +//! on the extracted bloom terms. Asserts against the generated `eql_v3_text` +//! fixtures (which carry `bf`). The containment operators `@>`/`<@` now RAISE on +//! this domain (covered in `text_smoke`). use sqlx::PgPool; const TABLE: &str = "fixtures.eql_v3_text"; @@ -18,27 +22,27 @@ async fn payload_for(pool: &PgPool, plaintext: &str) -> anyhow::Result anyhow::Result<()> { let p = payload_for(&pool, "aardvark").await?; let hit: bool = sqlx::query_scalar( - "SELECT ($1::jsonb::public.eql_v3_text_match) @> ($1::jsonb::public.eql_v3_text_match)", + "SELECT ($1::jsonb::public.eql_v3_text_match) @@ ($1::jsonb::public.eql_v3_text_match)", ) .bind(&p) .fetch_one(&pool) .await?; - assert!(hit, "a value's bloom filter must contain itself"); + assert!(hit, "a value's bloom filter must match itself"); Ok(()) } #[sqlx::test(fixtures(path = "../../../fixtures", scripts("eql_v3_text")))] -async fn haystack_contains_substring_needle(pool: PgPool) -> anyhow::Result<()> { +async fn haystack_matches_substring_needle(pool: PgPool) -> anyhow::Result<()> { let hay = payload_for(&pool, "aardvark").await?; let needle = payload_for(&pool, "aard").await?; let hit: bool = sqlx::query_scalar( - "SELECT ($1::jsonb::public.eql_v3_text_match) @> ($2::jsonb::public.eql_v3_text_match)", + "SELECT ($1::jsonb::public.eql_v3_text_match) @@ ($2::jsonb::public.eql_v3_text_match)", ) .bind(&hay) .bind(&needle) .fetch_one(&pool) .await?; - assert!(hit, "'aardvark' bloom must contain 'aard' (shared ngrams)"); + assert!(hit, "'aardvark' bloom must match 'aard' (shared ngrams)"); Ok(()) } @@ -52,7 +56,7 @@ async fn disjoint_value_does_not_match(pool: PgPool) -> anyhow::Result<()> { let hay = payload_for(&pool, "aard").await?; let needle = payload_for(&pool, "zzzz").await?; let hit: bool = sqlx::query_scalar( - "SELECT ($1::jsonb::public.eql_v3_text_match) @> ($2::jsonb::public.eql_v3_text_match)", + "SELECT ($1::jsonb::public.eql_v3_text_match) @@ ($2::jsonb::public.eql_v3_text_match)", ) .bind(&hay) .bind(&needle) @@ -60,17 +64,19 @@ async fn disjoint_value_does_not_match(pool: PgPool) -> anyhow::Result<()> { .await?; assert!( !hit, - "'aard' must not contain disjoint 'zzzz' (no shared ngrams)" + "'aard' must not match disjoint 'zzzz' (no shared ngrams)" ); Ok(()) } #[sqlx::test(fixtures(path = "../../../fixtures", scripts("eql_v3_text")))] -async fn match_uses_functional_index(pool: PgPool) -> anyhow::Result<()> { - // Explicit extractor form `match_term(col) @> match_term(needle)`. Forces - // `enable_seqscan = off` so this is an index-VALIDITY proof on the small - // fixture (not a cost-preference one), and uses the node-type-aware - // `assert_index_scan_uses` rather than a plan substring match. +async fn match_term_uses_functional_index(pool: PgPool) -> anyhow::Result<()> { + // Explicit extractor form `match_term(col) @> match_term(needle)` — the raw + // bloom array-containment the GIN index supports (unchanged by CIP-3517; the + // public `@@` operator reduces to exactly this). Forces `enable_seqscan = off` + // so this is an index-VALIDITY proof on the small fixture (not a + // cost-preference one), and uses the node-type-aware `assert_index_scan_uses` + // rather than a plan substring match. let mut tx = pool.begin().await?; sqlx::query("SET LOCAL enable_seqscan = off") .execute(&mut *tx) @@ -98,15 +104,15 @@ async fn match_uses_functional_index(pool: PgPool) -> anyhow::Result<()> { Ok(()) } -/// Companion to `match_uses_functional_index` proving the **bare operator** form -/// `WHERE col @> needle` (not the explicit `match_term(col) @> match_term(needle)`) -/// reaches the GIN index — i.e. the generated `@>` wrapper inlines through -/// `match_term` to the native array-containment the index supports. Forces -/// `enable_seqscan = off` so this is an index-**validity** proof on the small -/// fixture, not a cost-preference one, and uses the node-type-aware +/// Companion to `match_term_uses_functional_index` proving the **bare operator** +/// form `WHERE col @@ needle` (not the explicit `match_term(col) @> +/// match_term(needle)`) reaches the GIN index — i.e. the generated `eql_v3.matches` +/// wrapper inlines through `match_term` to the native array-containment the index +/// supports. Forces `enable_seqscan = off` so this is an index-**validity** proof +/// on the small fixture, not a cost-preference one, and uses the node-type-aware /// `assert_index_scan_uses` rather than a plan substring match. #[sqlx::test(fixtures(path = "../../../fixtures", scripts("eql_v3_text")))] -async fn bare_operator_uses_functional_index(pool: PgPool) -> anyhow::Result<()> { +async fn bare_matches_operator_uses_functional_index(pool: PgPool) -> anyhow::Result<()> { let mut tx = pool.begin().await?; sqlx::query("SET LOCAL enable_seqscan = off") .execute(&mut *tx) @@ -122,101 +128,31 @@ async fn bare_operator_uses_functional_index(pool: PgPool) -> anyhow::Result<()> let query = format!( "SELECT 1 FROM {TABLE} \ WHERE (payload::public.eql_v3_text_match) \ - @> ((SELECT payload::jsonb FROM {TABLE} WHERE plaintext = 'aard')::public.eql_v3_text_match)" + @@ ((SELECT payload::jsonb FROM {TABLE} WHERE plaintext = 'aard')::public.eql_v3_text_match)" ); eql_tests::matrix::assert_index_scan_uses( &mut *tx, &query, "text_match_idx", - "bare `@>` operator on text_match must engage the functional GIN index", + "bare `@@` operator on text_match must engage the functional GIN index", ) .await?; Ok(()) } #[sqlx::test(fixtures(path = "../../../fixtures", scripts("eql_v3_text")))] -async fn needle_contained_by_haystack(pool: PgPool) -> anyhow::Result<()> { - // `<@` (contained-by) is the COMMUTATOR of `@>`; the implemented - // `eql_v3.contained_by` is otherwise untested. `aard <@ aardvark` holds for - // the same shared-ngram reason `aardvark @> aard` does. - let needle = payload_for(&pool, "aard").await?; - let hay = payload_for(&pool, "aardvark").await?; - let hit: bool = sqlx::query_scalar( - "SELECT ($1::jsonb::public.eql_v3_text_match) <@ ($2::jsonb::public.eql_v3_text_match)", - ) - .bind(&needle) - .bind(&hay) - .fetch_one(&pool) - .await?; - assert!( - hit, - "'aard' bloom must be contained by 'aardvark' (shared ngrams)" - ); - Ok(()) -} - -#[sqlx::test(fixtures(path = "../../../fixtures", scripts("eql_v3_text")))] -async fn disjoint_value_not_contained_by(pool: PgPool) -> anyhow::Result<()> { - // `<@` negative, mirroring `disjoint_value_does_not_match`. "zzzz" (3-gram - // `zzz`) and "aard" (`aar`, `ard`) are ngram-disjoint in TEXT_FIXTURES, so - // this is a deterministic true negative (bloom filters admit false positives - // only for inputs that share n-grams). Keep them disjoint if the fixture - // list changes. - let needle = payload_for(&pool, "zzzz").await?; - let hay = payload_for(&pool, "aard").await?; - let hit: bool = sqlx::query_scalar( - "SELECT ($1::jsonb::public.eql_v3_text_match) <@ ($2::jsonb::public.eql_v3_text_match)", - ) - .bind(&needle) - .bind(&hay) - .fetch_one(&pool) - .await?; - assert!( - !hit, - "disjoint 'zzzz' must not be contained by 'aard' (no shared ngrams)" - ); - Ok(()) -} - -#[sqlx::test(fixtures(path = "../../../fixtures", scripts("eql_v3_text")))] -async fn contains_and_contained_by_are_commutative(pool: PgPool) -> anyhow::Result<()> { - // Pin the `COMMUTATOR = @>/<@` declaration behaviorally: `a @> b` must equal - // `b <@ a` for the same operand pair, and both hold for the superset/subset - // pair `aardvark`/`aard`. - let sup = payload_for(&pool, "aardvark").await?; - let sub = payload_for(&pool, "aard").await?; - let (contains, contained_by): (bool, bool) = sqlx::query_as( - "SELECT ($1::jsonb::public.eql_v3_text_match) @> ($2::jsonb::public.eql_v3_text_match), - ($2::jsonb::public.eql_v3_text_match) <@ ($1::jsonb::public.eql_v3_text_match)", - ) - .bind(&sup) - .bind(&sub) - .fetch_one(&pool) - .await?; - assert_eq!( - contains, contained_by, - "`a @> b` and `b <@ a` must agree (COMMUTATOR)" - ); - assert!( - contains, - "'aardvark' @> 'aard' must hold for the curated pair" - ); - Ok(()) -} - -#[sqlx::test(fixtures(path = "../../../fixtures", scripts("eql_v3_text")))] -async fn direct_contains_function_matches_operator(pool: PgPool) -> anyhow::Result<()> { - // Exercises `eql_v3.contains(a, b)` by NAME (not the `@>` operator), and pins - // that the function and the operator it backs agree. `aardvark` contains the +async fn direct_matches_function_matches_operator(pool: PgPool) -> anyhow::Result<()> { + // Exercises `eql_v3.matches(a, b)` by NAME (not the `@@` operator), and pins + // that the function and the operator it backs agree. `aardvark` matches the // substring needle `aard` (shared ngrams); the disjoint `zzzz` does not. let hay = payload_for(&pool, "aardvark").await?; let aard = payload_for(&pool, "aard").await?; let zzzz = payload_for(&pool, "zzzz").await?; let (fn_hit, op_hit, fn_miss): (bool, bool, bool) = sqlx::query_as( - "SELECT eql_v3.contains($1::jsonb::public.eql_v3_text_match, $2::jsonb::public.eql_v3_text_match), - ($1::jsonb::public.eql_v3_text_match) @> ($2::jsonb::public.eql_v3_text_match), - eql_v3.contains($1::jsonb::public.eql_v3_text_match, $3::jsonb::public.eql_v3_text_match)", + "SELECT eql_v3.matches($1::jsonb::public.eql_v3_text_match, $2::jsonb::public.eql_v3_text_match), + ($1::jsonb::public.eql_v3_text_match) @@ ($2::jsonb::public.eql_v3_text_match), + eql_v3.matches($1::jsonb::public.eql_v3_text_match, $3::jsonb::public.eql_v3_text_match)", ) .bind(&hay) .bind(&aard) @@ -224,48 +160,14 @@ async fn direct_contains_function_matches_operator(pool: PgPool) -> anyhow::Resu .fetch_one(&pool) .await?; - assert!(fn_hit, "eql_v3.contains('aardvark','aard') must be true"); - assert_eq!( - fn_hit, op_hit, - "eql_v3.contains must agree with the @> operator" - ); - assert!( - !fn_miss, - "eql_v3.contains('aardvark','zzzz') must be false (disjoint ngrams)" - ); - Ok(()) -} - -#[sqlx::test(fixtures(path = "../../../fixtures", scripts("eql_v3_text")))] -async fn direct_contained_by_function_matches_operator(pool: PgPool) -> anyhow::Result<()> { - // Exercises `eql_v3.contained_by(a, b)` by NAME (not the `<@` operator). `aard` - // is contained by `aardvark`; `zzzz` is not contained by `aard` (disjoint ngrams). - let aard = payload_for(&pool, "aard").await?; - let hay = payload_for(&pool, "aardvark").await?; - let zzzz = payload_for(&pool, "zzzz").await?; - - let (fn_hit, op_hit, fn_miss): (bool, bool, bool) = sqlx::query_as( - "SELECT eql_v3.contained_by($1::jsonb::public.eql_v3_text_match, $2::jsonb::public.eql_v3_text_match), - ($1::jsonb::public.eql_v3_text_match) <@ ($2::jsonb::public.eql_v3_text_match), - eql_v3.contained_by($3::jsonb::public.eql_v3_text_match, $1::jsonb::public.eql_v3_text_match)", - ) - .bind(&aard) - .bind(&hay) - .bind(&zzzz) - .fetch_one(&pool) - .await?; - - assert!( - fn_hit, - "eql_v3.contained_by('aard','aardvark') must be true" - ); + assert!(fn_hit, "eql_v3.matches('aardvark','aard') must be true"); assert_eq!( fn_hit, op_hit, - "eql_v3.contained_by must agree with the <@ operator" + "eql_v3.matches must agree with the @@ operator" ); assert!( !fn_miss, - "eql_v3.contained_by('zzzz','aard') must be false (disjoint ngrams)" + "eql_v3.matches('aardvark','zzzz') must be false (disjoint ngrams)" ); Ok(()) } @@ -274,19 +176,17 @@ async fn direct_contained_by_function_matches_operator(pool: PgPool) -> anyhow:: async fn mixed_jsonb_domain_overloads_agree(pool: PgPool) -> anyhow::Result<()> { // The (text_match, jsonb), (jsonb, text_match) overloads cast the jsonb side // internally; they must agree with the fully-cast (text_match, text_match) form. - // `aardvark` contains needle `aard` (shared ngrams). + // `aardvark` matches needle `aard` (shared ngrams). let hay = payload_for(&pool, "aardvark").await?; let aard = payload_for(&pool, "aard").await?; // $1 = haystack, $2 = needle. Each column leaves one operand as bare jsonb so a // DIFFERENT overload resolves; all must equal the all-domain baseline. - let row: (bool, bool, bool, bool, bool) = sqlx::query_as( + let row: (bool, bool, bool) = sqlx::query_as( "SELECT - eql_v3.contains($1::jsonb::public.eql_v3_text_match, $2::jsonb::public.eql_v3_text_match), -- baseline (domain,domain) - eql_v3.contains($1::jsonb::public.eql_v3_text_match, $2::jsonb), -- (domain, jsonb) - eql_v3.contains($1::jsonb, $2::jsonb::public.eql_v3_text_match), -- (jsonb, domain) - eql_v3.contained_by($2::jsonb::public.eql_v3_text_match, $1::jsonb), -- (domain, jsonb) - eql_v3.contained_by($2::jsonb, $1::jsonb::public.eql_v3_text_match) -- (jsonb, domain) + eql_v3.matches($1::jsonb::public.eql_v3_text_match, $2::jsonb::public.eql_v3_text_match), -- baseline (domain,domain) + eql_v3.matches($1::jsonb::public.eql_v3_text_match, $2::jsonb), -- (domain, jsonb) + eql_v3.matches($1::jsonb, $2::jsonb::public.eql_v3_text_match) -- (jsonb, domain) ", ) .bind(&hay) @@ -294,26 +194,18 @@ async fn mixed_jsonb_domain_overloads_agree(pool: PgPool) -> anyhow::Result<()> .fetch_one(&pool) .await?; - let (baseline, contains_dom_json, contains_json_dom, cby_dom_json, cby_json_dom) = row; + let (baseline, matches_dom_json, matches_json_dom) = row; assert!( baseline, - "baseline eql_v3.contains('aardvark','aard') must be true" - ); - assert_eq!( - contains_dom_json, baseline, - "contains(domain, jsonb) must agree" - ); - assert_eq!( - contains_json_dom, baseline, - "contains(jsonb, domain) must agree" + "baseline eql_v3.matches('aardvark','aard') must be true" ); assert_eq!( - cby_dom_json, baseline, - "contained_by(domain, jsonb) must agree (commutator of contains)" + matches_dom_json, baseline, + "matches(domain, jsonb) must agree" ); assert_eq!( - cby_json_dom, baseline, - "contained_by(jsonb, domain) must agree" + matches_json_dom, baseline, + "matches(jsonb, domain) must agree" ); Ok(()) } @@ -321,16 +213,15 @@ async fn mixed_jsonb_domain_overloads_agree(pool: PgPool) -> anyhow::Result<()> #[sqlx::test] async fn direct_functions_propagate_null(pool: PgPool) -> anyhow::Result<()> { // STRICT: a NULL operand short-circuits the body and returns NULL, not false - // and not an error. Covers the by-name functions (the operator path is covered + // and not an error. Covers the by-name function (the operator path is covered // by text_smoke::match_null_propagates) including a mixed (domain, jsonb) form. const BF: &str = r#"{"v":"3","i":{},"c":"x","bf":[1,2,3]}"#; - // $1 NULL, $2 a real payload — and the reverse — across both functions, both - // operand positions, and a mixed jsonb overload. + // $1 NULL, $2 a real payload — and the reverse — in both operand positions, + // and a mixed jsonb overload. for sql in [ - "SELECT eql_v3.contains($1::jsonb::public.eql_v3_text_match, $2::jsonb::public.eql_v3_text_match)", - "SELECT eql_v3.contained_by($1::jsonb::public.eql_v3_text_match, $2::jsonb::public.eql_v3_text_match)", - "SELECT eql_v3.contains($1::jsonb::public.eql_v3_text_match, $2::jsonb)", // mixed (domain, jsonb) + "SELECT eql_v3.matches($1::jsonb::public.eql_v3_text_match, $2::jsonb::public.eql_v3_text_match)", + "SELECT eql_v3.matches($1::jsonb::public.eql_v3_text_match, $2::jsonb)", // mixed (domain, jsonb) ] { eql_tests::assert_null(&pool, sql, &[None, Some(BF)]).await?; eql_tests::assert_null(&pool, sql, &[Some(BF), None]).await?; @@ -340,8 +231,8 @@ async fn direct_functions_propagate_null(pool: PgPool) -> anyhow::Result<()> { #[sqlx::test(fixtures(path = "../../../fixtures", scripts("eql_v3_text")))] async fn bloom_matches_where_like_would_not(pool: PgPool) -> anyhow::Result<()> { - // Locks in WHY v3 dropped `LIKE` for bloom containment: the two are not the same - // relation. The needle's ngrams are all present in the haystack, so bloom `@>` + // Locks in WHY v3 dropped `LIKE` for bloom matching: the two are not the same + // relation. The needle's ngrams are all present in the haystack, so bloom `@@` // matches — but the needle is NOT a contiguous substring, so `LIKE '%needle%'` // would NOT match. This false-positive / order-independence is the deterministic // divergence from LIKE (bloom has no false negatives, so the reverse can't happen). @@ -351,7 +242,7 @@ async fn bloom_matches_where_like_would_not(pool: PgPool) -> anyhow::Result<()> // 1. bloom DOES match. let bloom_hit: bool = sqlx::query_scalar( - "SELECT ($1::jsonb::public.eql_v3_text_match) @> ($2::jsonb::public.eql_v3_text_match)", + "SELECT ($1::jsonb::public.eql_v3_text_match) @@ ($2::jsonb::public.eql_v3_text_match)", ) .bind(&hay) .bind(&needle) @@ -359,18 +250,18 @@ async fn bloom_matches_where_like_would_not(pool: PgPool) -> anyhow::Result<()> .await?; assert!( bloom_hit, - "bloom @> must match: needle ngrams are a subset of the haystack's" + "bloom @@ must match: needle ngrams are a subset of the haystack's" ); - // 2. Pin the *structural* reason `@>` matched, independently of the domain - // operator. The domain `@>` is `match_term(a) @> match_term(b)`, i.e. + // 2. Pin the *structural* reason `@@` matched, independently of the domain + // operator. The domain `@@` is `match_term(a) @> match_term(b)`, i.e. // smallint[] array containment on the extracted bloom terms — so asserting it // again would just re-run the operator under test (circular). Instead assert // needle-bf ⊆ haystack-bf directly on the raw stored `bf` arrays via NATIVE // jsonb containment, which routes through neither `eql_v3.match_term` nor the // domain operator. This localizes a future tokenizer change (e.g. honoring // `include_original`, a different ngram width) to a precise "bf arrays no - // longer a subset" failure instead of an opaque `@>`-returned-false. + // longer a subset" failure instead of an opaque `@@`-returned-false. let bf_subset: bool = sqlx::query_scalar("SELECT ($1::jsonb -> 'bf') @> ($2::jsonb -> 'bf')") .bind(&hay) .bind(&needle) diff --git a/tests/sqlx/tests/encrypted_domain/text/text_smoke.rs b/tests/sqlx/tests/encrypted_domain/text/text_smoke.rs index 54852e558..0a1f7d227 100644 --- a/tests/sqlx/tests/encrypted_domain/text/text_smoke.rs +++ b/tests/sqlx/tests/encrypted_domain/text/text_smoke.rs @@ -1,12 +1,13 @@ //! Literal-payload smoke tests for the generated `public.eql_v3_text_match` surface: -//! `@>` / `<@` containment engages (supported wrappers), `=` raises (blocker), -//! `~~`/`~~*` are absent (no pattern-match), and the domain CHECK requires `bf`. -//! Uses hand-written jsonb payloads carrying `bf` — no encryption/fixtures -//! needed. The fixture-backed containment behaviour lives in `text_match.rs`. +//! `@@` fuzzy match engages (the `eql_v3.matches` wrapper), `=`/`@>`/`<@` raise +//! (blockers — `@@` is n-gram matching, NOT containment; CIP-3517), `~~`/`~~*` +//! are absent (no pattern-match), and the domain CHECK requires `bf`. Uses +//! hand-written jsonb payloads carrying `bf` — no encryption/fixtures needed. +//! The fixture-backed match behaviour lives in `text_match.rs`. use sqlx::PgPool; /// Build a literal `public.eql_v3_text_match` cast expression carrying bloom array -/// `bf` (e.g. `"[1,2,3]"` or `"[]"`). Lets these tests state set-containment +/// `bf` (e.g. `"[1,2,3]"` or `"[]"`). Lets these tests state set-membership /// semantics directly on `bf` arrays — deterministic, with no encryption and no /// bloom false positives to reason about. fn match_cast(bf: &str) -> String { @@ -14,15 +15,16 @@ fn match_cast(bf: &str) -> String { } #[sqlx::test] -async fn text_match_at_contains_engages(pool: PgPool) -> anyhow::Result<()> { - // self-containment: a filter contains a subset of itself +async fn text_match_at_at_engages(pool: PgPool) -> anyhow::Result<()> { + // self-match: a filter matches a subset of itself (`@@` reduces to bloom + // `match_term(a) @> match_term(b)`). let hit: bool = sqlx::query_scalar( "SELECT ('{\"v\":\"3\",\"i\":{},\"c\":\"x\",\"bf\":[1,2,3]}'::jsonb::public.eql_v3_text_match) - @> ('{\"v\":\"3\",\"i\":{},\"c\":\"x\",\"bf\":[2]}'::jsonb::public.eql_v3_text_match)", + @@ ('{\"v\":\"3\",\"i\":{},\"c\":\"x\",\"bf\":[2]}'::jsonb::public.eql_v3_text_match)", ) .fetch_one(&pool) .await?; - assert!(hit, "[1,2,3] @> [2] must hold"); + assert!(hit, "[1,2,3] @@ [2] must hold"); Ok(()) } @@ -42,11 +44,27 @@ async fn text_match_eq_is_blocked(pool: PgPool) -> anyhow::Result<()> { Ok(()) } +#[sqlx::test] +async fn text_match_containment_operators_are_blocked(pool: PgPool) -> anyhow::Result<()> { + // `@>` / `<@` are NOT the match operator on text_match — the fuzzy match is + // `@@` (`eql_v3.matches`). The containment operators are generated as blockers + // and must raise, so a caller who reaches for containment semantics gets a + // clear error instead of a silently-different result (CIP-3517). + const BF: &str = r#"{"v":"3","i":{},"c":"x","bf":[1,2,3]}"#; + for op in ["@>", "<@"] { + let sql = format!( + "SELECT ($1::jsonb::public.eql_v3_text_match) {op} ($2::jsonb::public.eql_v3_text_match)" + ); + eql_tests::assert_raises(&pool, &sql, &[Some(BF), Some(BF)], "not supported").await?; + } + Ok(()) +} + #[sqlx::test] async fn empty_bloom_has_empty_set_semantics(pool: PgPool) -> anyhow::Result<()> { // A value too short to tokenize (e.g. the empty string) yields an empty - // bloom filter (`bf: []`). Containment then follows empty-set semantics: - // everything contains the empty set; the empty set contains nothing. Uses + // bloom filter (`bf: []`). Matching then follows empty-set semantics: + // everything matches the empty needle; the empty filter matches nothing. Uses // literal payloads so the assertion is deterministic and independent of how // the encryptor renders a `bf` for a degenerate plaintext. const NON_EMPTY: &str = @@ -54,101 +72,56 @@ async fn empty_bloom_has_empty_set_semantics(pool: PgPool) -> anyhow::Result<()> const EMPTY: &str = "'{\"v\":\"3\",\"i\":{},\"c\":\"x\",\"bf\":[]}'::jsonb::public.eql_v3_text_match"; - let everything_contains_empty: bool = - sqlx::query_scalar(&format!("SELECT ({NON_EMPTY}) @> ({EMPTY})")) + let everything_matches_empty: bool = + sqlx::query_scalar(&format!("SELECT ({NON_EMPTY}) @@ ({EMPTY})")) .fetch_one(&pool) .await?; assert!( - everything_contains_empty, - "every filter must contain the empty filter" + everything_matches_empty, + "every filter must match the empty needle" ); - let empty_contains_nothing: bool = - sqlx::query_scalar(&format!("SELECT ({EMPTY}) @> ({NON_EMPTY})")) + let empty_matches_nothing: bool = + sqlx::query_scalar(&format!("SELECT ({EMPTY}) @@ ({NON_EMPTY})")) .fetch_one(&pool) .await?; assert!( - !empty_contains_nothing, - "empty filter must not contain a non-empty one" + !empty_matches_nothing, + "empty filter must not match a non-empty needle" ); Ok(()) } #[sqlx::test] async fn match_null_propagates(pool: PgPool) -> anyhow::Result<()> { - // `eql_v3.contains` / `eql_v3.contained_by` are STRICT, so a NULL operand - // yields NULL (three-valued logic) rather than false or an error. + // `eql_v3.matches` is STRICT, so a NULL operand yields NULL (three-valued + // logic) rather than false or an error. const BF: &str = r#"{"v":"3","i":{},"c":"x","bf":[1,2,3]}"#; - for op in ["@>", "<@"] { - let sql = - format!("SELECT ($1::jsonb::public.eql_v3_text_match) {op} ($2::jsonb::public.eql_v3_text_match)"); - eql_tests::assert_null(&pool, &sql, &[None, Some(BF)]).await?; - eql_tests::assert_null(&pool, &sql, &[Some(BF), None]).await?; - } - Ok(()) -} - -#[sqlx::test] -async fn text_match_contained_by_engages(pool: PgPool) -> anyhow::Result<()> { - // `<@` is the COMMUTATOR of `@>` and otherwise unexercised on literals. - let hit: bool = sqlx::query_scalar(&format!( - "SELECT ({}) <@ ({})", - match_cast("[2]"), - match_cast("[1,2,3]") - )) - .fetch_one(&pool) - .await?; - assert!(hit, "[2] <@ [1,2,3] must hold"); - Ok(()) -} - -#[sqlx::test] -async fn empty_bloom_contained_by_semantics(pool: PgPool) -> anyhow::Result<()> { - // `<@` mirror of the `@>` empty-set test: the empty filter is contained by - // everything; a non-empty filter is not contained by the empty filter. - let empty_in_everything: bool = sqlx::query_scalar(&format!( - "SELECT ({}) <@ ({})", - match_cast("[]"), - match_cast("[1,2,3]") - )) - .fetch_one(&pool) - .await?; - assert!( - empty_in_everything, - "the empty filter must be contained by every filter" - ); - - let nonempty_not_in_empty: bool = sqlx::query_scalar(&format!( - "SELECT ({}) <@ ({})", - match_cast("[1,2,3]"), - match_cast("[]") - )) - .fetch_one(&pool) - .await?; - assert!( - !nonempty_not_in_empty, - "a non-empty filter must not be contained by the empty filter" - ); + let sql = + "SELECT ($1::jsonb::public.eql_v3_text_match) @@ ($2::jsonb::public.eql_v3_text_match)"; + eql_tests::assert_null(&pool, sql, &[None, Some(BF)]).await?; + eql_tests::assert_null(&pool, sql, &[Some(BF), None]).await?; Ok(()) } #[sqlx::test] -async fn text_match_containment_requires_all_elements(pool: PgPool) -> anyhow::Result<()> { - // `@>` is set containment: the haystack bloom must include *every* element of - // the needle bloom. This is what makes it unlike SQL `LIKE` — there is no - // wildcard or anchoring, only "are all of these ngrams present". Asserted on - // literal `bf` arrays so it is deterministic (no bloom false positives). +async fn text_match_matches_requires_all_elements(pool: PgPool) -> anyhow::Result<()> { + // `@@` reduces to set containment on the bloom terms: the haystack bloom must + // include *every* element of the needle bloom. This is what makes it unlike + // SQL `LIKE` — there is no wildcard or anchoring, only "are all of these + // ngrams present". Asserted on literal `bf` arrays so it is deterministic (no + // bloom false positives). let cases = [ - ("[1,2,3]", "[1,2]", true), // proper subset + ("[1,2,3]", "[1,2]", true), // needle bloom is a proper subset ("[1,2,3]", "[3,4]", false), // partial overlap — 4 is absent ("[1,2]", "[3]", false), // disjoint ]; for (hay, needle, expected) in cases { - let sql = format!("SELECT ({}) @> ({})", match_cast(hay), match_cast(needle)); + let sql = format!("SELECT ({}) @@ ({})", match_cast(hay), match_cast(needle)); let hit: bool = sqlx::query_scalar(&sql).fetch_one(&pool).await?; assert_eq!( hit, expected, - "bf {hay} @> bf {needle} should be {expected}" + "bf {hay} @@ bf {needle} should be {expected}" ); } Ok(()) @@ -156,8 +129,8 @@ async fn text_match_containment_requires_all_elements(pool: PgPool) -> anyhow::R #[sqlx::test] async fn text_match_like_ilike_absent(pool: PgPool) -> anyhow::Result<()> { - // The bloom containment surface replaces deprecated `LIKE`/`ILIKE`, but it is - // NOT a pattern-match operator. `~~`/`~~*` are deliberately not declared on + // The bloom match surface replaces deprecated `LIKE`/`ILIKE`, but it is NOT a + // pattern-match operator. `~~`/`~~*` are deliberately not declared on // public.eql_v3_text_match, so they resolve to PostgreSQL's "operator does not // exist" rather than an EQL blocker. Pin that they stay absent on the very // domain a `LIKE` user would reach for. diff --git a/tests/sqlx/tests/v3_operator_equivalents_tests.rs b/tests/sqlx/tests/v3_operator_equivalents_tests.rs index f0eb4eaea..87bdca2d3 100644 --- a/tests/sqlx/tests/v3_operator_equivalents_tests.rs +++ b/tests/sqlx/tests/v3_operator_equivalents_tests.rs @@ -156,8 +156,10 @@ async fn core_public_function_equivalents_exist_in_eql_v3(pool: PgPool) -> Resul "lte", "gt", "gte", - "contains", - "contained_by", + // Bloom fuzzy match (`@@`) on the text match/search domains. `contains` + // /`contained_by` are NO LONGER public wrappers — they are now internal + // blockers on the text match domains (CIP-3517). + "matches", "jsonb_contains", "jsonb_contained_by", "jsonb_array", From 36b984397ab7ebe8e91e067b25242a6b7d4cc880 Mon Sep 17 00:00:00 2001 From: Toby Hede Date: Wed, 15 Jul 2026 21:58:37 +1000 Subject: [PATCH 12/19] refactor(eql-codegen): model operator symbol as OpSymbol enum MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Replace the stringly-typed `Operator.symbol: &'static str` field with a closed `OpSymbol` enum (20 variants, one per catalog operator) whose `as_str` is the single source of truth for the SQL operator text. `wrapper_function_name()` and `body_operator()` are now exhaustive `match self.symbol` with no wildcard `_ =>` arm — a future operator that needs a divergent wrapper name or body operator must be classified here (compile error until it is), instead of silently inheriting the default. Pure behaviour-preserving refactor: generated SQL/bindings/TS/JSON are byte-identical (codegen:parity → PARITY OK, types:check synced, all eql-codegen tests green). No changeset — internal codegen refactor with no observable change to any caller. --- crates/eql-codegen/src/context.rs | 4 +- crates/eql-codegen/src/generate.rs | 14 +- crates/eql-codegen/src/operator_surface.rs | 189 +++++++++++++++++---- 3 files changed, 166 insertions(+), 41 deletions(-) diff --git a/crates/eql-codegen/src/context.rs b/crates/eql-codegen/src/context.rs index 0fe6b7722..60bbc756b 100644 --- a/crates/eql-codegen/src/context.rs +++ b/crates/eql-codegen/src/context.rs @@ -289,7 +289,7 @@ pub fn wrapper_entry( pub fn unsupported_entry(op: &Operator, args: [SqlParam; 2], returns: &str) -> FnEntry { FnEntry::Unsupported { // operator_lit is sql_str-escaped defensively for the single-quoted RAISE literal. - operator_lit: sql_str(op.symbol), + operator_lit: sql_str(op.symbol.as_str()), function_name: op.function_name.to_string(), args, returns: returns.to_string(), @@ -344,7 +344,7 @@ pub fn operator_entry(op: &Operator, leftarg: &str, rightarg: &str, supported: b op.function_name }; OpEntry { - symbol: op.symbol.to_string(), + symbol: op.symbol.as_str().to_string(), function_name: function_name.to_string(), function_schema: function_schema.to_string(), leftarg: leftarg.to_string(), diff --git a/crates/eql-codegen/src/generate.rs b/crates/eql-codegen/src/generate.rs index c359e5450..6ffbaa807 100644 --- a/crates/eql-codegen/src/generate.rs +++ b/crates/eql-codegen/src/generate.rs @@ -117,12 +117,12 @@ pub fn render_functions_file(family_name: &str, domain: &Domain) -> String { entries.push(extractor_entry(term)); } for op in OPERATORS { - let extractor = Term::extractor_for_operator(domain.terms, op.symbol); + let extractor = Term::extractor_for_operator(domain.terms, op.symbol.as_str()); for sig in op.signatures { let rendered = sig.render(&dom); // A `blocker_only` overload (the `@@` jsonpath predicate) always falls // through to the blocker, even when the domain supports the symbol. - if is_supported(op.symbol) && !sig.blocker_only { + if is_supported(op.symbol.as_str()) && !sig.blocker_only { if let Some(ex) = extractor { entries.push(wrapper_entry(&dom, op, &rendered.left, &rendered.right, ex)); continue; @@ -134,7 +134,7 @@ pub fn render_functions_file(family_name: &str, domain: &Domain) -> String { ty: rendered.left, }, SqlParam { - name: arg_b_name(op.symbol), + name: arg_b_name(op.symbol.as_str()), ty: rendered.right, }, ]; @@ -177,7 +177,7 @@ pub fn render_operators_file(family_name: &str, domain: &Domain) -> String { op, &rendered.left, &rendered.right, - is_supported(op.symbol) && !sig.blocker_only, + is_supported(op.symbol.as_str()) && !sig.blocker_only, )); } } @@ -243,10 +243,10 @@ pub fn render_query_functions_file(family_name: &str, domain: &Domain) -> String // jsonb`, which no caller writes; blocking them would mean emitting the full // blocker matrix against every query twin for zero real-world coverage. for op in OPERATORS { - if !supported.contains(&op.symbol) { + if !supported.contains(&op.symbol.as_str()) { continue; } - let extractor = Term::extractor_for_operator(domain.terms, op.symbol) + let extractor = Term::extractor_for_operator(domain.terms, op.symbol.as_str()) .expect("a supported operator resolves an extractor"); entries.push(wrapper_entry( &query_dom, @@ -299,7 +299,7 @@ pub fn render_query_operators_file(family_name: &str, domain: &Domain) -> String let mut operators = Vec::new(); for op in OPERATORS { - if !supported.contains(&op.symbol) { + if !supported.contains(&op.symbol.as_str()) { continue; } operators.push(operator_entry(op, &storage_dom, &query_dom, true)); diff --git a/crates/eql-codegen/src/operator_surface.rs b/crates/eql-codegen/src/operator_surface.rs index 9aa75bf02..d3a804e19 100644 --- a/crates/eql-codegen/src/operator_surface.rs +++ b/crates/eql-codegen/src/operator_surface.rs @@ -1,9 +1,91 @@ //! The generated operator surface. +/// The closed set of SQL operator symbols the generator knows about. Modelling +/// the symbol as an enum (rather than a bare `&'static str`) makes the two +/// methods that diverge on it — `wrapper_function_name` and `body_operator` — +/// **exhaustive, compiler-checked matches**: adding a new operator forces a +/// compile error at those match sites until the author explicitly classifies +/// it, rather than silently inheriting a `_ =>` default. +/// +/// `as_str` is the single source of truth for each variant's SQL text. +#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)] +pub enum OpSymbol { + /// `=` + Eq, + /// `<>` + Neq, + /// `<` + Lt, + /// `<=` + Lte, + /// `>` + Gt, + /// `>=` + Gte, + /// `@>` + Contains, + /// `<@` + ContainedBy, + /// `->` + Arrow, + /// `->>` + ArrowArrow, + /// `?` + Question, + /// `?|` + QuestionPipe, + /// `?&` + QuestionAmp, + /// `@?` + AtQuestion, + /// `@@` + Match, + /// `#>` + HashArrow, + /// `#>>` + HashArrowArrow, + /// `-` + Minus, + /// `#-` + HashMinus, + /// `||` + Concat, +} + +impl OpSymbol { + /// The SQL operator text for this symbol (e.g. `OpSymbol::Eq => "="`). The + /// single source of truth for the string form — every raw-string use site + /// (SQL rendering, snapshot output, lookups) goes through here. + pub const fn as_str(&self) -> &'static str { + match self { + OpSymbol::Eq => "=", + OpSymbol::Neq => "<>", + OpSymbol::Lt => "<", + OpSymbol::Lte => "<=", + OpSymbol::Gt => ">", + OpSymbol::Gte => ">=", + OpSymbol::Contains => "@>", + OpSymbol::ContainedBy => "<@", + OpSymbol::Arrow => "->", + OpSymbol::ArrowArrow => "->>", + OpSymbol::Question => "?", + OpSymbol::QuestionPipe => "?|", + OpSymbol::QuestionAmp => "?&", + OpSymbol::AtQuestion => "@?", + OpSymbol::Match => "@@", + OpSymbol::HashArrow => "#>", + OpSymbol::HashArrowArrow => "#>>", + OpSymbol::Minus => "-", + OpSymbol::HashMinus => "#-", + OpSymbol::Concat => "||", + } + } +} + /// One operator in the generated surface. #[derive(Clone, Copy)] pub struct Operator { - pub symbol: &'static str, + pub symbol: OpSymbol, pub function_name: &'static str, pub signatures: &'static [OperatorSignature], pub metadata: OperatorMetadata, @@ -222,7 +304,7 @@ pub fn operator(symbol: &str) -> Operator { OPERATORS .iter() .copied() - .find(|o| o.symbol == symbol) + .find(|o| o.symbol.as_str() == symbol) .unwrap_or_else(|| panic!("unknown operator symbol: {symbol}")) } @@ -242,9 +324,10 @@ impl Operator { const COMPARISON: &[&str] = &["=", "<>", "<", "<=", ">", ">="]; const CONTAINMENT: &[&str] = &["@>", "<@"]; const PATH_SELECTOR: &[&str] = &["->", "->>"]; - !COMPARISON.contains(&self.symbol) - && !CONTAINMENT.contains(&self.symbol) - && !PATH_SELECTOR.contains(&self.symbol) + let symbol = self.symbol.as_str(); + !COMPARISON.contains(&symbol) + && !CONTAINMENT.contains(&symbol) + && !PATH_SELECTOR.contains(&symbol) } /// The name of the SUPPORTED comparison-wrapper function for this operator @@ -254,9 +337,30 @@ impl Operator { /// blocker name `eql_v3_internal."@@"`. The blocker path always uses /// `function_name`; only the wrapper/supported path calls this. pub fn wrapper_function_name(&self) -> &'static str { + // Exhaustive on purpose: no `_ =>` fallthrough. A future operator that + // needs a divergent wrapper name must be classified here (compile error + // until it is), rather than silently inheriting `function_name`. match self.symbol { - "@@" => "matches", - _ => self.function_name, + OpSymbol::Match => "matches", + OpSymbol::Eq + | OpSymbol::Neq + | OpSymbol::Lt + | OpSymbol::Lte + | OpSymbol::Gt + | OpSymbol::Gte + | OpSymbol::Contains + | OpSymbol::ContainedBy + | OpSymbol::Arrow + | OpSymbol::ArrowArrow + | OpSymbol::Question + | OpSymbol::QuestionPipe + | OpSymbol::QuestionAmp + | OpSymbol::AtQuestion + | OpSymbol::HashArrow + | OpSymbol::HashArrowArrow + | OpSymbol::Minus + | OpSymbol::HashMinus + | OpSymbol::Concat => self.function_name, } } @@ -269,9 +373,30 @@ impl Operator { /// `contains` wrapper produced — no new operator on the SEM bloom_filter type, /// and the proven single-level inline to the array `@>` GIN opclass is kept. pub fn body_operator(&self) -> &'static str { + // Exhaustive on purpose: no `_ =>` fallthrough. A future operator whose + // wrapper body must use a different SQL operator than its own symbol + // must be classified here (compile error until it is). match self.symbol { - "@@" => "@>", - _ => self.symbol, + OpSymbol::Match => "@>", + OpSymbol::Eq + | OpSymbol::Neq + | OpSymbol::Lt + | OpSymbol::Lte + | OpSymbol::Gt + | OpSymbol::Gte + | OpSymbol::Contains + | OpSymbol::ContainedBy + | OpSymbol::Arrow + | OpSymbol::ArrowArrow + | OpSymbol::Question + | OpSymbol::QuestionPipe + | OpSymbol::QuestionAmp + | OpSymbol::AtQuestion + | OpSymbol::HashArrow + | OpSymbol::HashArrowArrow + | OpSymbol::Minus + | OpSymbol::HashMinus + | OpSymbol::Concat => self.symbol.as_str(), } } } @@ -283,7 +408,7 @@ pub fn native_jsonb_blocker_symbols() -> Vec<&'static str> { OPERATORS .iter() .filter(|o| o.is_native_jsonb_blocker()) - .map(|o| o.symbol) + .map(|o| o.symbol.as_str()) .collect() } @@ -331,121 +456,121 @@ const fn match_metadata() -> OperatorMetadata { /// operators, then the remaining native jsonb operators. pub const OPERATORS: &[Operator] = &[ Operator { - symbol: "=", + symbol: OpSymbol::Eq, function_name: "eq", signatures: BOOL_SYMMETRIC_SIGNATURES, metadata: cmp_metadata("eqsel", "eqjoinsel", "=", "<>"), }, Operator { - symbol: "<>", + symbol: OpSymbol::Neq, function_name: "neq", signatures: BOOL_SYMMETRIC_SIGNATURES, metadata: cmp_metadata("neqsel", "neqjoinsel", "<>", "="), }, Operator { - symbol: "<", + symbol: OpSymbol::Lt, function_name: "lt", signatures: BOOL_SYMMETRIC_SIGNATURES, metadata: cmp_metadata("scalarltsel", "scalarltjoinsel", ">", ">="), }, Operator { - symbol: "<=", + symbol: OpSymbol::Lte, function_name: "lte", signatures: BOOL_SYMMETRIC_SIGNATURES, metadata: cmp_metadata("scalarlesel", "scalarlejoinsel", ">=", ">"), }, Operator { - symbol: ">", + symbol: OpSymbol::Gt, function_name: "gt", signatures: BOOL_SYMMETRIC_SIGNATURES, metadata: cmp_metadata("scalargtsel", "scalargtjoinsel", "<", "<="), }, Operator { - symbol: ">=", + symbol: OpSymbol::Gte, function_name: "gte", signatures: BOOL_SYMMETRIC_SIGNATURES, metadata: cmp_metadata("scalargesel", "scalargejoinsel", "<=", "<"), }, Operator { - symbol: "@>", + symbol: OpSymbol::Contains, function_name: "contains", signatures: BOOL_SYMMETRIC_SIGNATURES, metadata: containment_metadata("<@"), }, Operator { - symbol: "<@", + symbol: OpSymbol::ContainedBy, function_name: "contained_by", signatures: BOOL_SYMMETRIC_SIGNATURES, metadata: containment_metadata("@>"), }, Operator { - symbol: "->", + symbol: OpSymbol::Arrow, function_name: "\"->\"", signatures: ARROW_SIGNATURES, metadata: OperatorMetadata::none(), }, Operator { - symbol: "->>", + symbol: OpSymbol::ArrowArrow, function_name: "\"->>\"", signatures: ARROW_TEXT_SIGNATURES, metadata: OperatorMetadata::none(), }, Operator { - symbol: "?", + symbol: OpSymbol::Question, function_name: "\"?\"", signatures: HAS_KEY_SIGNATURES, metadata: OperatorMetadata::none(), }, Operator { - symbol: "?|", + symbol: OpSymbol::QuestionPipe, function_name: "\"?|\"", signatures: HAS_ANY_KEYS_SIGNATURES, metadata: OperatorMetadata::none(), }, Operator { - symbol: "?&", + symbol: OpSymbol::QuestionAmp, function_name: "\"?&\"", signatures: HAS_ANY_KEYS_SIGNATURES, metadata: OperatorMetadata::none(), }, Operator { - symbol: "@?", + symbol: OpSymbol::AtQuestion, function_name: "\"@?\"", signatures: JSONPATH_SIGNATURES, metadata: OperatorMetadata::none(), }, Operator { - symbol: "@@", + symbol: OpSymbol::Match, function_name: "\"@@\"", signatures: MATCH_SIGNATURES, metadata: match_metadata(), }, Operator { - symbol: "#>", + symbol: OpSymbol::HashArrow, function_name: "\"#>\"", signatures: PATH_EXTRACT_JSONB_SIGNATURES, metadata: OperatorMetadata::none(), }, Operator { - symbol: "#>>", + symbol: OpSymbol::HashArrowArrow, function_name: "\"#>>\"", signatures: PATH_EXTRACT_TEXT_SIGNATURES, metadata: OperatorMetadata::none(), }, Operator { - symbol: "-", + symbol: OpSymbol::Minus, function_name: "\"-\"", signatures: DELETE_SIGNATURES, metadata: OperatorMetadata::none(), }, Operator { - symbol: "#-", + symbol: OpSymbol::HashMinus, function_name: "\"#-\"", signatures: DELETE_PATH_SIGNATURES, metadata: OperatorMetadata::none(), }, Operator { - symbol: "||", + symbol: OpSymbol::Concat, function_name: "\"||\"", signatures: CONCAT_SIGNATURES, metadata: OperatorMetadata::none(), @@ -621,7 +746,7 @@ mod tests { fn no_like_operators() { assert!(OPERATORS .iter() - .all(|o| o.symbol != "~~" && o.symbol != "~~*")); + .all(|o| o.symbol.as_str() != "~~" && o.symbol.as_str() != "~~*")); } #[test] @@ -698,7 +823,7 @@ mod tests { #[test] fn catalog_symbols_match_expected_order() { - let keys: Vec<&str> = OPERATORS.iter().map(|o| o.symbol).collect(); + let keys: Vec<&str> = OPERATORS.iter().map(|o| o.symbol.as_str()).collect(); assert_eq!( keys, vec![ From e0db50c5ee7568c53489ae849a778069daa60e39 Mon Sep 17 00:00:00 2001 From: Toby Hede Date: Thu, 16 Jul 2026 14:41:18 +1000 Subject: [PATCH 13/19] ci(release): allow prereleases from any non-main branch MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The prerelease pipeline was hardwired to the retired eql_v3 branch, so no prerelease could be cut from a release batching branch (e.g. eql-3.0.1) without merging to main. Generalize classify to grant prerelease mode to any non-main branch carrying a chore(release): marker commit, dispatched via workflow_dispatch. Safety is unchanged — it comes from the marker commit, the prerelease-shaped version guard, and the tag-idempotency short-circuit, not the branch name. Drop the dead eql_v3 entry from on: push. --- .github/workflows/release.yml | 20 +++++++++++++------- 1 file changed, 13 insertions(+), 7 deletions(-) diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 2c26586a0..4098f071a 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -3,8 +3,11 @@ name: "Release" # Single release entry point for the EQL release line. # # - `main` uses Changesets to version and publish the production release. -# - `eql_v3` can cut prereleases from an explicit conventional release commit. -# The release commit itself is the marker: `chore(release): ...`. +# - Any non-`main` branch can cut a prerelease from an explicit conventional +# release commit, triggered via workflow_dispatch against that branch (e.g. +# `gh workflow run release.yml --ref eql-3.0.1`). The release commit itself is +# the marker: `chore(release): ...`. This lets a batching branch ship an +# alpha/rc for pre-merge testing without merging to `main`. # # Prereleases publish the npm package directly from this workflow and dispatch # the Rust crate publish through `release-plz.yml` so crates.io Trusted @@ -23,7 +26,6 @@ on: push: branches: - main - - eql_v3 workflow_dispatch: {} concurrency: @@ -60,10 +62,14 @@ jobs: if [[ "$branch" == "main" ]]; then mode="production" - elif [[ "$branch" == "eql_v3" ]]; then - # Exactly `chore(release):` — a bare `release:` prefix would let an - # unrelated commit ("release: fix runbook") re-trigger the publish - # pipeline for the currently pinned identity. + else + # Any non-main branch cuts a prerelease from an explicit + # conventional release commit (dispatched via workflow_dispatch). + # Safety comes from the three guards below — the marker commit, the + # prerelease-shaped version, and the tag-idempotency short-circuit — + # not from the branch name. Exactly `chore(release):`; a bare + # `release:` prefix must NOT re-trigger the publish pipeline for the + # currently pinned identity. case "$subject" in chore\(release\):*) mode="prerelease" From e7790ab6429b92e6d3cd61d6364c6eadb9b039c4 Mon Sep 17 00:00:00 2001 From: Toby Hede Date: Thu, 16 Jul 2026 14:57:22 +1000 Subject: [PATCH 14/19] chore(release): eql 3.0.1-alpha.0 --- Cargo.lock | 2 +- crates/eql-bindings/Cargo.toml | 2 +- .../eql-bindings/sql/cipherstash-encrypt.sql | 19421 +++++++++++----- crates/eql-bindings/sql/release-manifest.json | 4 +- packages/eql/CHANGELOG.md | 7 + packages/eql/package.json | 2 +- packages/eql/sql/cipherstash-encrypt.sql | 19421 +++++++++++----- packages/eql/sql/release-manifest.json | 4 +- .../eql/src/generated/release-manifest.ts | 4 +- 9 files changed, 28262 insertions(+), 10605 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 9132e6136..656e0904c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1164,7 +1164,7 @@ dependencies = [ [[package]] name = "eql-bindings" -version = "3.0.0" +version = "3.0.1-alpha.0" dependencies = [ "eql-domains", "schemars", diff --git a/crates/eql-bindings/Cargo.toml b/crates/eql-bindings/Cargo.toml index 7265daa3e..ee6fa150e 100644 --- a/crates/eql-bindings/Cargo.toml +++ b/crates/eql-bindings/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "eql-bindings" -version = "3.0.0" +version = "3.0.1-alpha.0" edition = "2021" description = "Canonical wire types for EQL payloads — single source of truth for Rust, TypeScript (ts-rs), and JSON Schema (schemars)." # crates.io metadata. `license` is REQUIRED by crates.io — publish fails without diff --git a/crates/eql-bindings/sql/cipherstash-encrypt.sql b/crates/eql-bindings/sql/cipherstash-encrypt.sql index 286ae1050..4e5e70bf0 100644 --- a/crates/eql-bindings/sql/cipherstash-encrypt.sql +++ b/crates/eql-bindings/sql/cipherstash-encrypt.sql @@ -1095,261 +1095,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) >= eql_v3.ord_term_ore(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b public.eql_v3_real_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_real_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b public.eql_v3_real_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_real_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param selector text ---! @return public.eql_v3_real_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_real_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ore, selector text) RETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param selector integer ---! @return public.eql_v3_real_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_real_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ore, selector integer) RETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_real_ord_ore ---! @return public.eql_v3_real_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator +--! @return public.eql_v3_real_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_ord_ore) RETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_real_ord_ore ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b public.eql_v3_real_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_real_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_real_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b public.eql_v3_real_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_real_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$ @@ -1515,369 +1660,574 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) <> eql_v3.eq_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a jsonb ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a jsonb ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a jsonb ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a jsonb ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a jsonb ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a jsonb ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param selector text ---! @return public.eql_v3_smallint_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_smallint_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_eq, selector text) RETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param selector integer ---! @return public.eql_v3_smallint_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_smallint_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_eq, selector integer) RETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a jsonb ---! @param selector public.eql_v3_smallint_eq ---! @return public.eql_v3_smallint_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator +--! @return public.eql_v3_smallint_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint_eq) RETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a jsonb ---! @param selector public.eql_v3_smallint_eq ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint_eq) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a jsonb ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a jsonb ---! @param b public.eql_v3_smallint_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$ @@ -2241,369 +2591,574 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) <> eql_v3.eq_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param selector text ---! @return public.eql_v3_double_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_double_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_eq, selector text) RETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param selector integer ---! @return public.eql_v3_double_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_double_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_eq, selector integer) RETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param selector public.eql_v3_double_eq ---! @return public.eql_v3_double_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_double_eq right operand of the blocked operator +--! @return public.eql_v3_double_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double_eq) RETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param selector public.eql_v3_double_eq ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_double_eq right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double_eq) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_eq, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_eq, b public.eql_v3_double_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$ @@ -3134,261 +3689,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b public.eql_v3_text_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b public.eql_v3_text_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a jsonb ---! @param b public.eql_v3_text_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b public.eql_v3_text_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b public.eql_v3_text_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a jsonb ---! @param b public.eql_v3_text_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param selector text ---! @return public.eql_v3_text_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_text_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord, selector text) RETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param selector integer ---! @return public.eql_v3_text_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_text_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord, selector integer) RETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a jsonb ---! @param selector public.eql_v3_text_ord ---! @return public.eql_v3_text_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_ord right operand of the blocked operator +--! @return public.eql_v3_text_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_ord) RETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a jsonb ---! @param selector public.eql_v3_text_ord ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_ord right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_ord) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b public.eql_v3_text_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b public.eql_v3_text_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a jsonb ---! @param b public.eql_v3_text_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b public.eql_v3_text_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b public.eql_v3_text_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a jsonb ---! @param b public.eql_v3_text_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$ @@ -3512,369 +4212,574 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) <> eql_v3.eq_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param selector text ---! @return public.eql_v3_timestamp_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_timestamp_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_eq, selector text) RETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param selector integer ---! @return public.eql_v3_timestamp_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_timestamp_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_eq, selector integer) RETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a jsonb ---! @param selector public.eql_v3_timestamp_eq ---! @return public.eql_v3_timestamp_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return public.eql_v3_timestamp_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_eq) RETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a jsonb ---! @param selector public.eql_v3_timestamp_eq ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_eq) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$ @@ -3984,423 +4889,658 @@ $$; --! @brief Functions for public.eql_v3_bigint. --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param selector text ---! @return public.eql_v3_bigint +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_bigint never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint, selector text) RETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param selector integer ---! @return public.eql_v3_bigint +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_bigint never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint, selector integer) RETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param selector public.eql_v3_bigint ---! @return public.eql_v3_bigint +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_bigint right operand of the blocked operator +--! @return public.eql_v3_bigint never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint) RETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param selector public.eql_v3_bigint ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_bigint right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint, b public.eql_v3_bigint) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$ @@ -4563,261 +5703,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b public.eql_v3_bigint_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b public.eql_v3_bigint_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param selector text ---! @return public.eql_v3_bigint_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_bigint_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord, selector text) RETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param selector integer ---! @return public.eql_v3_bigint_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_bigint_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord, selector integer) RETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a jsonb ---! @param selector public.eql_v3_bigint_ord ---! @return public.eql_v3_bigint_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator +--! @return public.eql_v3_bigint_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_ord) RETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a jsonb ---! @param selector public.eql_v3_bigint_ord ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_ord) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b public.eql_v3_bigint_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_bigint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b public.eql_v3_bigint_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$ @@ -5070,261 +6355,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) >= eql_v3.ord_term_ore(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param selector text ---! @return public.eql_v3_bigint_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ore, selector text) RETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param selector integer ---! @return public.eql_v3_bigint_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ore, selector integer) RETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_bigint_ord_ore ---! @return public.eql_v3_bigint_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_ord_ore) RETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_bigint_ord_ore ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_bigint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$ @@ -6307,261 +7737,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b public.eql_v3_real_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b public.eql_v3_real_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a jsonb ---! @param b public.eql_v3_real_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b public.eql_v3_real_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b public.eql_v3_real_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a jsonb ---! @param b public.eql_v3_real_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param selector text ---! @return public.eql_v3_real_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_real_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord, selector text) RETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param selector integer ---! @return public.eql_v3_real_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_real_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord, selector integer) RETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a jsonb ---! @param selector public.eql_v3_real_ord ---! @return public.eql_v3_real_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_real_ord right operand of the blocked operator +--! @return public.eql_v3_real_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_ord) RETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a jsonb ---! @param selector public.eql_v3_real_ord ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_real_ord right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_ord) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b public.eql_v3_real_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b public.eql_v3_real_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a jsonb ---! @param b public.eql_v3_real_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_real_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b public.eql_v3_real_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b public.eql_v3_real_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a jsonb ---! @param b public.eql_v3_real_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$ @@ -6628,369 +8203,574 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) <> eql_v3.eq_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a jsonb ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a jsonb ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a jsonb ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a jsonb ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a jsonb ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a jsonb ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param selector text ---! @return public.eql_v3_real_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_real_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_eq, selector text) RETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param selector integer ---! @return public.eql_v3_real_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_real_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_eq, selector integer) RETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a jsonb ---! @param selector public.eql_v3_real_eq ---! @return public.eql_v3_real_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_real_eq right operand of the blocked operator +--! @return public.eql_v3_real_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_eq) RETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a jsonb ---! @param selector public.eql_v3_real_eq ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_real_eq right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_eq) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a jsonb ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a jsonb ---! @param b public.eql_v3_real_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$ @@ -7153,261 +8933,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b public.eql_v3_real_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_real_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b public.eql_v3_real_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_real_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param selector text ---! @return public.eql_v3_real_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_real_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ope, selector text) RETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param selector integer ---! @return public.eql_v3_real_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_real_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ope, selector integer) RETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_real_ord_ope ---! @return public.eql_v3_real_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator +--! @return public.eql_v3_real_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_ord_ope) RETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_real_ord_ope ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b public.eql_v3_real_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_real_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_real_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b public.eql_v3_real_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_real_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$ @@ -7722,261 +9647,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) >= eql_v3.ord_term_ore(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b public.eql_v3_smallint_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_smallint_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b public.eql_v3_smallint_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_smallint_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param selector text ---! @return public.eql_v3_smallint_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_ord_ore, selector text) RETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param selector integer ---! @return public.eql_v3_smallint_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_ord_ore, selector integer) RETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_smallint_ord_ore ---! @return public.eql_v3_smallint_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint_ord_ore) RETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_smallint_ord_ore ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b public.eql_v3_smallint_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_smallint_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_smallint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b public.eql_v3_smallint_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_smallint_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$ @@ -8486,261 +10556,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_smallint_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_smallint_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param selector text ---! @return public.eql_v3_smallint_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_ord_ope, selector text) RETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param selector integer ---! @return public.eql_v3_smallint_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_ord_ope, selector integer) RETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_smallint_ord_ope ---! @return public.eql_v3_smallint_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint_ord_ope) RETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_smallint_ord_ope ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_smallint_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_smallint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_smallint_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$ @@ -8903,261 +11118,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b public.eql_v3_smallint_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a jsonb ---! @param b public.eql_v3_smallint_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b public.eql_v3_smallint_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a jsonb ---! @param b public.eql_v3_smallint_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param selector text ---! @return public.eql_v3_smallint_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_smallint_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_ord, selector text) RETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param selector integer ---! @return public.eql_v3_smallint_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_smallint_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_ord, selector integer) RETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a jsonb ---! @param selector public.eql_v3_smallint_ord ---! @return public.eql_v3_smallint_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator +--! @return public.eql_v3_smallint_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint_ord) RETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a jsonb ---! @param selector public.eql_v3_smallint_ord ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint_ord) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b public.eql_v3_smallint_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a jsonb ---! @param b public.eql_v3_smallint_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_smallint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b public.eql_v3_smallint_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a jsonb ---! @param b public.eql_v3_smallint_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$ @@ -9320,423 +11680,658 @@ AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; --! @brief Functions for public.eql_v3_smallint. --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param selector text ---! @return public.eql_v3_smallint +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_smallint never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint, selector text) RETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param selector integer ---! @return public.eql_v3_smallint +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_smallint never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint, selector integer) RETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param selector public.eql_v3_smallint ---! @return public.eql_v3_smallint +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_smallint right operand of the blocked operator +--! @return public.eql_v3_smallint never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint) RETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param selector public.eql_v3_smallint ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_smallint right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$ @@ -10156,261 +12751,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b public.eql_v3_date_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b public.eql_v3_date_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b public.eql_v3_date_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a jsonb ---! @param b public.eql_v3_date_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b public.eql_v3_date_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b public.eql_v3_date_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b public.eql_v3_date_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a jsonb ---! @param b public.eql_v3_date_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param selector text ---! @return public.eql_v3_date_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_date_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord, selector text) RETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param selector integer ---! @return public.eql_v3_date_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_date_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord, selector integer) RETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a jsonb ---! @param selector public.eql_v3_date_ord ---! @return public.eql_v3_date_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_date_ord right operand of the blocked operator +--! @return public.eql_v3_date_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_ord) RETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a jsonb ---! @param selector public.eql_v3_date_ord ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_date_ord right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_ord) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b public.eql_v3_date_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b public.eql_v3_date_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord, b public.eql_v3_date_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a jsonb ---! @param b public.eql_v3_date_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_date_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b public.eql_v3_date_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b public.eql_v3_date_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord, b public.eql_v3_date_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a jsonb ---! @param b public.eql_v3_date_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$ @@ -10771,261 +13511,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) >= eql_v3.ord_term_ore(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b public.eql_v3_date_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_date_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b public.eql_v3_date_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_date_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param selector text ---! @return public.eql_v3_date_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_date_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ore, selector text) RETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param selector integer ---! @return public.eql_v3_date_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_date_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ore, selector integer) RETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_date_ord_ore ---! @return public.eql_v3_date_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator +--! @return public.eql_v3_date_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_ord_ore) RETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_date_ord_ore ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b public.eql_v3_date_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_date_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_date_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b public.eql_v3_date_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_date_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$ @@ -11188,261 +14073,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b public.eql_v3_date_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_date_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b public.eql_v3_date_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_date_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param selector text ---! @return public.eql_v3_date_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_date_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ope, selector text) RETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param selector integer ---! @return public.eql_v3_date_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_date_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ope, selector integer) RETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_date_ord_ope ---! @return public.eql_v3_date_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator +--! @return public.eql_v3_date_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_ord_ope) RETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_date_ord_ope ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b public.eql_v3_date_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_date_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_date_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b public.eql_v3_date_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_date_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$ @@ -11509,369 +14539,574 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) <> eql_v3.eq_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a jsonb ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a jsonb ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a jsonb ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a jsonb ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a jsonb ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a jsonb ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param selector text ---! @return public.eql_v3_date_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_date_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_eq, selector text) RETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param selector integer ---! @return public.eql_v3_date_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_date_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_eq, selector integer) RETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a jsonb ---! @param selector public.eql_v3_date_eq ---! @return public.eql_v3_date_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_date_eq right operand of the blocked operator +--! @return public.eql_v3_date_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_eq) RETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a jsonb ---! @param selector public.eql_v3_date_eq ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_date_eq right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_eq) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a jsonb ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a jsonb ---! @param b public.eql_v3_date_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$ @@ -11882,423 +15117,658 @@ LANGUAGE plpgsql; --! @brief Functions for public.eql_v3_date. --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param selector text ---! @return public.eql_v3_date +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_date never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date, selector text) RETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param selector integer ---! @return public.eql_v3_date +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_date never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date, selector integer) RETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param selector public.eql_v3_date ---! @return public.eql_v3_date +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_date right operand of the blocked operator +--! @return public.eql_v3_date never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date) RETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param selector public.eql_v3_date ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_date right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date, b public.eql_v3_date) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$ @@ -12969,369 +16439,574 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_numeric_eq) <> eql_v3.eq_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a jsonb ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a jsonb ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a jsonb ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a jsonb ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a jsonb ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a jsonb ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param selector text ---! @return public.eql_v3_numeric_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_numeric_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_eq, selector text) RETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param selector integer ---! @return public.eql_v3_numeric_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_numeric_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_eq, selector integer) RETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a jsonb ---! @param selector public.eql_v3_numeric_eq ---! @return public.eql_v3_numeric_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator +--! @return public.eql_v3_numeric_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric_eq) RETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a jsonb ---! @param selector public.eql_v3_numeric_eq ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric_eq) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a jsonb ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b public.eql_v3_numeric_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a jsonb ---! @param b public.eql_v3_numeric_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$ @@ -13494,261 +17169,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param selector text ---! @return public.eql_v3_numeric_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_numeric_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord, selector text) RETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param selector integer ---! @return public.eql_v3_numeric_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_numeric_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord, selector integer) RETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param selector public.eql_v3_numeric_ord ---! @return public.eql_v3_numeric_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator +--! @return public.eql_v3_numeric_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric_ord) RETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param selector public.eql_v3_numeric_ord ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric_ord) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_numeric_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$ @@ -14019,261 +17839,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) >= eql_v3.ord_term_ore(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param selector text ---! @return public.eql_v3_numeric_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ore, selector text) RETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param selector integer ---! @return public.eql_v3_numeric_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ore, selector integer) RETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_numeric_ord_ore ---! @return public.eql_v3_numeric_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric_ord_ore) RETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_numeric_ord_ore ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$ @@ -14544,261 +18509,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param selector text ---! @return public.eql_v3_numeric_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ope, selector text) RETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param selector integer ---! @return public.eql_v3_numeric_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ope, selector integer) RETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_numeric_ord_ope ---! @return public.eql_v3_numeric_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric_ord_ope) RETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_numeric_ord_ope ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$ @@ -15456,423 +19566,658 @@ $$; --! @brief Functions for public.eql_v3_json. --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a jsonb ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a jsonb ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a jsonb ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a jsonb ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a jsonb ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a jsonb ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a jsonb ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a jsonb ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param selector text ---! @return public.eql_v3_json +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_json never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_json, selector text) RETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param selector integer ---! @return public.eql_v3_json +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_json never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_json, selector integer) RETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a jsonb ---! @param selector public.eql_v3_json ---! @return public.eql_v3_json +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_json right operand of the blocked operator +--! @return public.eql_v3_json never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_json) RETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_json, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_json, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a jsonb ---! @param selector public.eql_v3_json ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_json right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_json) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_json, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_json, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_json, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_json, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_json, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a jsonb ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_json, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_json, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_json, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_json, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_json, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_json, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_json, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b public.eql_v3_json ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_json, b public.eql_v3_json) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_json, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a jsonb ---! @param b public.eql_v3_json ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_json) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$ @@ -16125,261 +20470,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b public.eql_v3_double_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b public.eql_v3_double_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord, b public.eql_v3_double_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a jsonb ---! @param b public.eql_v3_double_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b public.eql_v3_double_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b public.eql_v3_double_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord, b public.eql_v3_double_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a jsonb ---! @param b public.eql_v3_double_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param selector text ---! @return public.eql_v3_double_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_double_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord, selector text) RETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param selector integer ---! @return public.eql_v3_double_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_double_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord, selector integer) RETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a jsonb ---! @param selector public.eql_v3_double_ord ---! @return public.eql_v3_double_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_double_ord right operand of the blocked operator +--! @return public.eql_v3_double_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double_ord) RETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a jsonb ---! @param selector public.eql_v3_double_ord ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_double_ord right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double_ord) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b public.eql_v3_double_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b public.eql_v3_double_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord, b public.eql_v3_double_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a jsonb ---! @param b public.eql_v3_double_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_double_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b public.eql_v3_double_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b public.eql_v3_double_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord, b public.eql_v3_double_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a jsonb ---! @param b public.eql_v3_double_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$ @@ -16542,261 +21032,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) >= eql_v3.ord_term_ore(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b public.eql_v3_double_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_double_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b public.eql_v3_double_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_double_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param selector text ---! @return public.eql_v3_double_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_double_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord_ore, selector text) RETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param selector integer ---! @return public.eql_v3_double_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_double_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord_ore, selector integer) RETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_double_ord_ore ---! @return public.eql_v3_double_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator +--! @return public.eql_v3_double_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double_ord_ore) RETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_double_ord_ore ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b public.eql_v3_double_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_double_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_double_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b public.eql_v3_double_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_double_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$ @@ -16959,261 +21594,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b public.eql_v3_double_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_double_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b public.eql_v3_double_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_double_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param selector text ---! @return public.eql_v3_double_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_double_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord_ope, selector text) RETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param selector integer ---! @return public.eql_v3_double_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_double_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord_ope, selector integer) RETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_double_ord_ope ---! @return public.eql_v3_double_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator +--! @return public.eql_v3_double_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double_ord_ope) RETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_double_ord_ope ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b public.eql_v3_double_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_double_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_double_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b public.eql_v3_double_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_double_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$ @@ -17738,423 +22518,658 @@ CREATE OPERATOR || ( --! @brief Functions for public.eql_v3_double. --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param selector text ---! @return public.eql_v3_double +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_double never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double, selector text) RETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param selector integer ---! @return public.eql_v3_double +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_double never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double, selector integer) RETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param selector public.eql_v3_double ---! @return public.eql_v3_double +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_double right operand of the blocked operator +--! @return public.eql_v3_double never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double) RETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param selector public.eql_v3_double ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_double right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double, b public.eql_v3_double) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$ @@ -18522,369 +23537,574 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) <> eql_v3.eq_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param selector text ---! @return public.eql_v3_integer_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_integer_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_eq, selector text) RETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param selector integer ---! @return public.eql_v3_integer_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_integer_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_eq, selector integer) RETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param selector public.eql_v3_integer_eq ---! @return public.eql_v3_integer_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_integer_eq right operand of the blocked operator +--! @return public.eql_v3_integer_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_eq) RETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param selector public.eql_v3_integer_eq ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_integer_eq right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_eq) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$ @@ -19047,261 +24267,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b public.eql_v3_integer_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b public.eql_v3_integer_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a jsonb ---! @param b public.eql_v3_integer_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b public.eql_v3_integer_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b public.eql_v3_integer_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a jsonb ---! @param b public.eql_v3_integer_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param selector text ---! @return public.eql_v3_integer_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_integer_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord, selector text) RETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param selector integer ---! @return public.eql_v3_integer_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_integer_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord, selector integer) RETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a jsonb ---! @param selector public.eql_v3_integer_ord ---! @return public.eql_v3_integer_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_integer_ord right operand of the blocked operator +--! @return public.eql_v3_integer_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_ord) RETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a jsonb ---! @param selector public.eql_v3_integer_ord ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_integer_ord right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_ord) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b public.eql_v3_integer_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b public.eql_v3_integer_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a jsonb ---! @param b public.eql_v3_integer_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_integer_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b public.eql_v3_integer_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b public.eql_v3_integer_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a jsonb ---! @param b public.eql_v3_integer_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$ @@ -19721,261 +25086,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) >= eql_v3.ord_term_ore(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_integer_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_integer_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param selector text ---! @return public.eql_v3_integer_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_integer_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ore, selector text) RETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param selector integer ---! @return public.eql_v3_integer_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_integer_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ore, selector integer) RETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_integer_ord_ore ---! @return public.eql_v3_integer_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @return public.eql_v3_integer_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_ord_ore) RETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_integer_ord_ore ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_integer_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_integer_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$ @@ -20485,261 +25995,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_integer_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_integer_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param selector text ---! @return public.eql_v3_integer_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_integer_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ope, selector text) RETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param selector integer ---! @return public.eql_v3_integer_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_integer_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ope, selector integer) RETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_integer_ord_ope ---! @return public.eql_v3_integer_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @return public.eql_v3_integer_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_ord_ope) RETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_integer_ord_ope ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_integer_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_integer_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$ @@ -20750,423 +26405,658 @@ LANGUAGE plpgsql; --! @brief Functions for public.eql_v3_integer. --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param selector text ---! @return public.eql_v3_integer +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_integer never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer, selector text) RETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param selector integer ---! @return public.eql_v3_integer +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_integer never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer, selector integer) RETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param selector public.eql_v3_integer ---! @return public.eql_v3_integer +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_integer right operand of the blocked operator +--! @return public.eql_v3_integer never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer) RETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param selector public.eql_v3_integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$ @@ -21515,306 +27405,476 @@ LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a jsonb ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a jsonb ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a jsonb ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a jsonb ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a jsonb ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a jsonb ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a jsonb ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a jsonb ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param selector text ---! @return public.eql_v3_text_match +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_text_match never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_match, selector text) RETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param selector integer ---! @return public.eql_v3_text_match +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_text_match never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_match, selector integer) RETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a jsonb ---! @param selector public.eql_v3_text_match ---! @return public.eql_v3_text_match +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_match right operand of the blocked operator +--! @return public.eql_v3_text_match never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_match) RETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_match, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_match, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a jsonb ---! @param selector public.eql_v3_text_match ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_match right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_match) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_match, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_match, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_match, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_match, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_match'; END; $$ @@ -21845,90 +27905,140 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_match) @> eql_v3.match_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_match, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_match, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_match, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_match, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_match, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_match, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_match, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_match, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a jsonb ---! @param b public.eql_v3_text_match ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_match) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$ @@ -22099,261 +28209,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b public.eql_v3_text_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b public.eql_v3_text_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param selector text ---! @return public.eql_v3_text_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_text_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ope, selector text) RETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param selector integer ---! @return public.eql_v3_text_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_text_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ope, selector integer) RETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_text_ord_ope ---! @return public.eql_v3_text_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator +--! @return public.eql_v3_text_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_ord_ope) RETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_text_ord_ope ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b public.eql_v3_text_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_text_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b public.eql_v3_text_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$ @@ -22640,261 +28895,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) >= eql_v3.ord_term_ore(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param selector text ---! @return public.eql_v3_text_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_text_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ore, selector text) RETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param selector integer ---! @return public.eql_v3_text_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_text_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ore, selector integer) RETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_text_ord_ore ---! @return public.eql_v3_text_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator +--! @return public.eql_v3_text_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_ord_ore) RETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_text_ord_ore ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_text_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$ @@ -22961,369 +29361,574 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) <> eql_v3.eq_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a jsonb ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a jsonb ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a jsonb ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a jsonb ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a jsonb ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a jsonb ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param selector text ---! @return public.eql_v3_text_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_text_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_eq, selector text) RETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param selector integer ---! @return public.eql_v3_text_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_text_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_eq, selector integer) RETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a jsonb ---! @param selector public.eql_v3_text_eq ---! @return public.eql_v3_text_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_eq right operand of the blocked operator +--! @return public.eql_v3_text_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_eq) RETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a jsonb ---! @param selector public.eql_v3_text_eq ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_eq right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_eq) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a jsonb ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a jsonb ---! @param b public.eql_v3_text_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$ @@ -23502,144 +30107,224 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b public.eql_v3_text_search ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b public.eql_v3_text_search right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b public.eql_v3_text_search) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a jsonb ---! @param b public.eql_v3_text_search ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_search right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b public.eql_v3_text_search ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b public.eql_v3_text_search right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b public.eql_v3_text_search) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a jsonb ---! @param b public.eql_v3_text_search ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_search right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param selector text ---! @return public.eql_v3_text_search +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_text_search never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search, selector text) RETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param selector integer ---! @return public.eql_v3_text_search +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_text_search never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search, selector integer) RETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a jsonb ---! @param selector public.eql_v3_text_search ---! @return public.eql_v3_text_search +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_search right operand of the blocked operator +--! @return public.eql_v3_text_search never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_search) RETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a jsonb ---! @param selector public.eql_v3_text_search ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_search right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_search) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_search, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_search, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_search, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_search, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search'; END; $$ @@ -23670,90 +30355,140 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search) @> eql_v3.match_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_search, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_search, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_search, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_search, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b public.eql_v3_text_search ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b public.eql_v3_text_search right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search, b public.eql_v3_text_search) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a jsonb ---! @param b public.eql_v3_text_search ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_search right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_search) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$ @@ -23932,144 +30667,224 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) >= eql_v3.ord_term_ore(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b public.eql_v3_text_search_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b public.eql_v3_text_search_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_search_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_search_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b public.eql_v3_text_search_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b public.eql_v3_text_search_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_search_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_search_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param selector text ---! @return public.eql_v3_text_search_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_text_search_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search_ore, selector text) RETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param selector integer ---! @return public.eql_v3_text_search_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_text_search_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search_ore, selector integer) RETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a jsonb ---! @param selector public.eql_v3_text_search_ore ---! @return public.eql_v3_text_search_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator +--! @return public.eql_v3_text_search_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_search_ore) RETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a jsonb ---! @param selector public.eql_v3_text_search_ore ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_search_ore) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_search_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_search_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_search_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_search_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search_ore'; END; $$ @@ -24100,90 +30915,140 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search_ore) @> eql_v3.match_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_search_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_search_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_search_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_search_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b public.eql_v3_text_search_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b public.eql_v3_text_search_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_search_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_search_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_search_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$ @@ -24860,261 +31725,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) >= eql_v3.ord_term_ore(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param selector text ---! @return public.eql_v3_timestamp_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ore, selector text) RETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param selector integer ---! @return public.eql_v3_timestamp_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ore, selector integer) RETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_timestamp_ord_ore ---! @return public.eql_v3_timestamp_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_ord_ore) RETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_timestamp_ord_ore ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_timestamp_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$ @@ -25277,261 +32287,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b public.eql_v3_timestamp_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b public.eql_v3_timestamp_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param selector text ---! @return public.eql_v3_timestamp_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_timestamp_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord, selector text) RETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param selector integer ---! @return public.eql_v3_timestamp_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_timestamp_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord, selector integer) RETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a jsonb ---! @param selector public.eql_v3_timestamp_ord ---! @return public.eql_v3_timestamp_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator +--! @return public.eql_v3_timestamp_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_ord) RETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a jsonb ---! @param selector public.eql_v3_timestamp_ord ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_ord) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b public.eql_v3_timestamp_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_timestamp_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b public.eql_v3_timestamp_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$ @@ -25995,261 +33150,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param selector text ---! @return public.eql_v3_timestamp_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ope, selector text) RETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param selector integer ---! @return public.eql_v3_timestamp_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ope, selector integer) RETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_timestamp_ord_ope ---! @return public.eql_v3_timestamp_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_ord_ope) RETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_timestamp_ord_ope ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$ @@ -27506,7 +34806,7 @@ DROP FUNCTION IF EXISTS eql_v3.version(); --! @brief EQL version reporting (self-contained eql_v3 surface) --! --! This file is auto-generated from src/v3/version.template during build. ---! The 3.0.0 placeholder is replaced with the actual release +--! The 3.0.1-alpha.0 placeholder is replaced with the actual release --! version (bare semver, e.g. "3.0.0") supplied via `mise run build --version`, --! or "DEV" for development builds. @@ -27525,14 +34825,14 @@ CREATE FUNCTION eql_v3.version() RETURNS text IMMUTABLE STRICT PARALLEL SAFE AS $$ - SELECT '3.0.0'; + SELECT '3.0.1-alpha.0'; $$ LANGUAGE SQL; --! @brief Schema-level version marker for obj_description() discoverability --! --! Mirrors eql_v3.version() as a comment on the schema so the installed --! version can also be read via obj_description('eql_v3'::regnamespace). -COMMENT ON SCHEMA eql_v3 IS '3.0.0'; +COMMENT ON SCHEMA eql_v3 IS '3.0.1-alpha.0'; --! @brief EQL lint: detect non-inlinable operator implementation functions --! @@ -28234,369 +35534,574 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) <> eql_v3.eq_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a jsonb ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a jsonb ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a jsonb ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a jsonb ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a jsonb ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a jsonb ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param selector text ---! @return public.eql_v3_bigint_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_bigint_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_eq, selector text) RETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param selector integer ---! @return public.eql_v3_bigint_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_bigint_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_eq, selector integer) RETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a jsonb ---! @param selector public.eql_v3_bigint_eq ---! @return public.eql_v3_bigint_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator +--! @return public.eql_v3_bigint_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_eq) RETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a jsonb ---! @param selector public.eql_v3_bigint_eq ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_eq) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a jsonb ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a jsonb ---! @param b public.eql_v3_bigint_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$ @@ -28911,261 +36416,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param selector text ---! @return public.eql_v3_bigint_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ope, selector text) RETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param selector integer ---! @return public.eql_v3_bigint_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ope, selector integer) RETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_bigint_ord_ope ---! @return public.eql_v3_bigint_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_ord_ope) RETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_bigint_ord_ope ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_bigint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$ @@ -31333,423 +38983,658 @@ CREATE OPERATOR >= ( --! @brief Functions for public.eql_v3_real. --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a jsonb ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a jsonb ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a jsonb ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a jsonb ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a jsonb ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a jsonb ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a jsonb ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a jsonb ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param selector text ---! @return public.eql_v3_real +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_real never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real, selector text) RETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param selector integer ---! @return public.eql_v3_real +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_real never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real, selector integer) RETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a jsonb ---! @param selector public.eql_v3_real ---! @return public.eql_v3_real +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_real right operand of the blocked operator +--! @return public.eql_v3_real never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real) RETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a jsonb ---! @param selector public.eql_v3_real ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_real right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a jsonb ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real, b public.eql_v3_real) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a jsonb ---! @param b public.eql_v3_real ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$ @@ -35450,423 +43335,658 @@ CREATE OPERATOR >= ( --! @brief Functions for public.eql_v3_numeric. --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param selector text ---! @return public.eql_v3_numeric +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_numeric never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric, selector text) RETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param selector integer ---! @return public.eql_v3_numeric +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_numeric never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric, selector integer) RETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param selector public.eql_v3_numeric ---! @return public.eql_v3_numeric +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_numeric right operand of the blocked operator +--! @return public.eql_v3_numeric never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric) RETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param selector public.eql_v3_numeric ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_numeric right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$ @@ -37160,423 +45280,658 @@ $$; --! @brief Functions for public.eql_v3_boolean. --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param selector text ---! @return public.eql_v3_boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_boolean, selector text) RETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param selector integer ---! @return public.eql_v3_boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_boolean, selector integer) RETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param selector public.eql_v3_boolean ---! @return public.eql_v3_boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_boolean right operand of the blocked operator +--! @return public.eql_v3_boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_boolean) RETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_boolean, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_boolean, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param selector public.eql_v3_boolean ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_boolean right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_boolean) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_boolean, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_boolean, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_boolean, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_boolean, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_boolean, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_boolean, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_boolean, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_boolean, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_boolean, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_boolean, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_boolean, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_boolean, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_boolean, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_boolean, b public.eql_v3_boolean) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_boolean, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_boolean) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$ @@ -40719,423 +49074,658 @@ AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; --! @brief Functions for public.eql_v3_text. --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a jsonb ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a jsonb ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a jsonb ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a jsonb ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a jsonb ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a jsonb ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a jsonb ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a jsonb ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param selector text ---! @return public.eql_v3_text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text, selector text) RETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param selector integer ---! @return public.eql_v3_text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text, selector integer) RETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a jsonb ---! @param selector public.eql_v3_text ---! @return public.eql_v3_text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text right operand of the blocked operator +--! @return public.eql_v3_text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text) RETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a jsonb ---! @param selector public.eql_v3_text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a jsonb ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text, b public.eql_v3_text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a jsonb ---! @param b public.eql_v3_text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$ @@ -43943,423 +52533,658 @@ CREATE OPERATOR @@ ( --! @brief Functions for public.eql_v3_timestamp. --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a jsonb ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a jsonb ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a jsonb ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a jsonb ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a jsonb ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a jsonb ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a jsonb ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a jsonb ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param selector text ---! @return public.eql_v3_timestamp +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_timestamp never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp, selector text) RETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param selector integer ---! @return public.eql_v3_timestamp +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_timestamp never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp, selector integer) RETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a jsonb ---! @param selector public.eql_v3_timestamp ---! @return public.eql_v3_timestamp +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_timestamp right operand of the blocked operator +--! @return public.eql_v3_timestamp never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp) RETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a jsonb ---! @param selector public.eql_v3_timestamp ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_timestamp right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a jsonb ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp, b public.eql_v3_timestamp) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a jsonb ---! @param b public.eql_v3_timestamp ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$ diff --git a/crates/eql-bindings/sql/release-manifest.json b/crates/eql-bindings/sql/release-manifest.json index b27c45e21..635e57c3e 100644 --- a/crates/eql-bindings/sql/release-manifest.json +++ b/crates/eql-bindings/sql/release-manifest.json @@ -1,6 +1,6 @@ { - "eqlVersion": "3.0.0", + "eqlVersion": "3.0.1-alpha.0", "schemaVersion": 3, - "installSqlSha256": "6da5ed462b02f53a0636d783880533496eecfb52218d718791085376bc44c6a0", + "installSqlSha256": "8e3321fb74e3bef2881cdbe6dc0b94742c7192360b9e94742177794f9476c597", "uninstallSqlSha256": "b1b5131b8175c5d04da9ada108d25c81c5772b15fad79a6c419ebb32d18c60a9" } diff --git a/packages/eql/CHANGELOG.md b/packages/eql/CHANGELOG.md index 8c71b73bc..77fdc0258 100644 --- a/packages/eql/CHANGELOG.md +++ b/packages/eql/CHANGELOG.md @@ -1,5 +1,12 @@ # @cipherstash/eql +## 3.0.1-alpha.0 + +### Patch Changes + +- a8ec17c: **The encrypted-JSON domains are renamed for a consistent `public.eql_v3_json` family, and a new ciphertext-only storage domain is added.** The bare name `public.eql_v3_json` is now a **storage-only** domain (a single opaque ciphertext, `{v,i,c}` envelope, no index terms — the JSON analogue of `public.eql_v3_boolean`, for encrypt-at-rest with no server-side searchability). The searchable SteVec document that previously held the bare `public.eql_v3_json` name is renamed to `public.eql_v3_json_search`; its supporting domains follow: `public.eql_v3_jsonb_entry` → `public.eql_v3_json_entry`, and the containment needle `eql_v3.query_jsonb` → `eql_v3.query_json`. This makes the JSON family follow the same convention as every scalar family — the bare family name is the storage-only domain and a suffix (`_search`, mirroring text's `_search`) marks the searchable variant. Reach for `public.eql_v3_json_search` when you need containment/field queries over encrypted JSON (`@>`, path access) and `public.eql_v3_json` when you only need to store and round-trip an encrypted JSON value. Callers on the previous names must update column declarations and query casts (`WHERE doc @> $1::eql_v3.query_json`); the bindings, `DomainPayload`/`QueryPayload` parse names, and published JSON Schema file names all move to the new names. +- 18d58e7: **Text bloom fuzzy match is renamed to `@@` / `eql_v3.matches` — it is n-gram token matching, not containment.** On the text match/search domains (`public.eql_v3_text_match`, `public.eql_v3_text_search`, `public.eql_v3_text_search_ore`) the fuzzy match was previously spelled with the containment operators `@>` / `<@`, backed by `eql_v3.contains` / `eql_v3.contained_by`. That promised substring/containment semantics the operation does not provide: it is array containment over two bloom filters built from the downcased 3-gram token set — a probabilistic, order- and multiplicity-insensitive, one-sided match (a `true` may be a false positive; a `false` never is). The match is now a single directional operator `@@` backed by `eql_v3.matches` (`WHERE col @@ $1::public.eql_v3_text_match`), and the reverse `contained_by` direction is dropped. `@>` and `<@` now **raise** "operator not supported" on the text match domains. The functional GIN index recipe is unchanged (`GIN (eql_v3.match_term(col))`): `col @@ $1` inlines through `match_term` to the same array-containment the index supports. Genuine JSON containment (`public.eql_v3_json_search` `@>`/`<@`, `eql_v3.ste_vec_contains`) keeps the containment vocabulary and is unaffected. This is the SQL-layer counterpart of the SDK's `contains()` → `matches()` rename; callers or SDKs emitting `eql_v3.contains(col, …)` / `col @> $1` for text match must switch to `eql_v3.matches(col, …)` / `col @@ $1` in lockstep. See upgrade note U-008. + ## 3.0.0 ### Major Changes diff --git a/packages/eql/package.json b/packages/eql/package.json index 4eb14744e..2a05e2db6 100644 --- a/packages/eql/package.json +++ b/packages/eql/package.json @@ -1,6 +1,6 @@ { "name": "@cipherstash/eql", - "version": "3.0.0", + "version": "3.0.1-alpha.0", "description": "Canonical EQL v3 wire types, JSON schemas, and SQL bundle.", "keywords": [ "eql", diff --git a/packages/eql/sql/cipherstash-encrypt.sql b/packages/eql/sql/cipherstash-encrypt.sql index 286ae1050..4e5e70bf0 100644 --- a/packages/eql/sql/cipherstash-encrypt.sql +++ b/packages/eql/sql/cipherstash-encrypt.sql @@ -1095,261 +1095,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) >= eql_v3.ord_term_ore(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b public.eql_v3_real_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_real_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b public.eql_v3_real_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_real_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param selector text ---! @return public.eql_v3_real_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_real_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ore, selector text) RETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param selector integer ---! @return public.eql_v3_real_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_real_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ore, selector integer) RETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_real_ord_ore ---! @return public.eql_v3_real_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator +--! @return public.eql_v3_real_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_ord_ore) RETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_real_ord_ore ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b public.eql_v3_real_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_real_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_real_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b public.eql_v3_real_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_real_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$ @@ -1515,369 +1660,574 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) <> eql_v3.eq_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a jsonb ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a jsonb ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a jsonb ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a jsonb ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a jsonb ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a jsonb ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param selector text ---! @return public.eql_v3_smallint_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_smallint_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_eq, selector text) RETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param selector integer ---! @return public.eql_v3_smallint_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_smallint_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_eq, selector integer) RETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a jsonb ---! @param selector public.eql_v3_smallint_eq ---! @return public.eql_v3_smallint_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator +--! @return public.eql_v3_smallint_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint_eq) RETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a jsonb ---! @param selector public.eql_v3_smallint_eq ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint_eq) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a jsonb ---! @param b public.eql_v3_smallint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. ---! @param a jsonb ---! @param b public.eql_v3_smallint_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$ @@ -2241,369 +2591,574 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) <> eql_v3.eq_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param selector text ---! @return public.eql_v3_double_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_double_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_eq, selector text) RETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param selector integer ---! @return public.eql_v3_double_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_double_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_eq, selector integer) RETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param selector public.eql_v3_double_eq ---! @return public.eql_v3_double_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_double_eq right operand of the blocked operator +--! @return public.eql_v3_double_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double_eq) RETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param selector public.eql_v3_double_eq ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_double_eq right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double_eq) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_eq, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_eq, b public.eql_v3_double_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_eq. ---! @param a jsonb ---! @param b public.eql_v3_double_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$ @@ -3134,261 +3689,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b public.eql_v3_text_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b public.eql_v3_text_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a jsonb ---! @param b public.eql_v3_text_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b public.eql_v3_text_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b public.eql_v3_text_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a jsonb ---! @param b public.eql_v3_text_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param selector text ---! @return public.eql_v3_text_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_text_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord, selector text) RETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param selector integer ---! @return public.eql_v3_text_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_text_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord, selector integer) RETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a jsonb ---! @param selector public.eql_v3_text_ord ---! @return public.eql_v3_text_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_ord right operand of the blocked operator +--! @return public.eql_v3_text_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_ord) RETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a jsonb ---! @param selector public.eql_v3_text_ord ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_ord right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_ord) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b public.eql_v3_text_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b public.eql_v3_text_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a jsonb ---! @param b public.eql_v3_text_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b public.eql_v3_text_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b public.eql_v3_text_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord, b public.eql_v3_text_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord. ---! @param a jsonb ---! @param b public.eql_v3_text_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$ @@ -3512,369 +4212,574 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) <> eql_v3.eq_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param selector text ---! @return public.eql_v3_timestamp_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_timestamp_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_eq, selector text) RETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param selector integer ---! @return public.eql_v3_timestamp_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_timestamp_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_eq, selector integer) RETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a jsonb ---! @param selector public.eql_v3_timestamp_eq ---! @return public.eql_v3_timestamp_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return public.eql_v3_timestamp_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_eq) RETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a jsonb ---! @param selector public.eql_v3_timestamp_eq ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_eq) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$ @@ -3984,423 +4889,658 @@ $$; --! @brief Functions for public.eql_v3_bigint. --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param selector text ---! @return public.eql_v3_bigint +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_bigint never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint, selector text) RETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param selector integer ---! @return public.eql_v3_bigint +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_bigint never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint, selector integer) RETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param selector public.eql_v3_bigint ---! @return public.eql_v3_bigint +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_bigint right operand of the blocked operator +--! @return public.eql_v3_bigint never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint) RETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param selector public.eql_v3_bigint ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_bigint right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b public.eql_v3_bigint ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint, b public.eql_v3_bigint) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a public.eql_v3_bigint ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint. ---! @param a jsonb ---! @param b public.eql_v3_bigint ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$ @@ -4563,261 +5703,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b public.eql_v3_bigint_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b public.eql_v3_bigint_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param selector text ---! @return public.eql_v3_bigint_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_bigint_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord, selector text) RETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param selector integer ---! @return public.eql_v3_bigint_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_bigint_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord, selector integer) RETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a jsonb ---! @param selector public.eql_v3_bigint_ord ---! @return public.eql_v3_bigint_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator +--! @return public.eql_v3_bigint_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_ord) RETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a jsonb ---! @param selector public.eql_v3_bigint_ord ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_ord) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b public.eql_v3_bigint_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_bigint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b public.eql_v3_bigint_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$ @@ -5070,261 +6355,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) >= eql_v3.ord_term_ore(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param selector text ---! @return public.eql_v3_bigint_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ore, selector text) RETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param selector integer ---! @return public.eql_v3_bigint_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ore, selector integer) RETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_bigint_ord_ore ---! @return public.eql_v3_bigint_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_ord_ore) RETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_bigint_ord_ore ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_bigint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$ @@ -6307,261 +7737,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b public.eql_v3_real_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b public.eql_v3_real_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a jsonb ---! @param b public.eql_v3_real_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b public.eql_v3_real_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b public.eql_v3_real_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a jsonb ---! @param b public.eql_v3_real_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param selector text ---! @return public.eql_v3_real_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_real_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord, selector text) RETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param selector integer ---! @return public.eql_v3_real_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_real_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord, selector integer) RETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a jsonb ---! @param selector public.eql_v3_real_ord ---! @return public.eql_v3_real_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_real_ord right operand of the blocked operator +--! @return public.eql_v3_real_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_ord) RETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a jsonb ---! @param selector public.eql_v3_real_ord ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_real_ord right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_ord) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b public.eql_v3_real_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b public.eql_v3_real_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a jsonb ---! @param b public.eql_v3_real_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_real_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b public.eql_v3_real_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b public.eql_v3_real_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord, b public.eql_v3_real_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord. ---! @param a jsonb ---! @param b public.eql_v3_real_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$ @@ -6628,369 +8203,574 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) <> eql_v3.eq_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a jsonb ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a jsonb ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a jsonb ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a jsonb ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a jsonb ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a jsonb ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param selector text ---! @return public.eql_v3_real_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_real_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_eq, selector text) RETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param selector integer ---! @return public.eql_v3_real_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_real_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_eq, selector integer) RETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a jsonb ---! @param selector public.eql_v3_real_eq ---! @return public.eql_v3_real_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_real_eq right operand of the blocked operator +--! @return public.eql_v3_real_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_eq) RETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a jsonb ---! @param selector public.eql_v3_real_eq ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_real_eq right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_eq) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a jsonb ---! @param b public.eql_v3_real_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_eq, b public.eql_v3_real_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_eq. ---! @param a jsonb ---! @param b public.eql_v3_real_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$ @@ -7153,261 +8933,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b public.eql_v3_real_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_real_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b public.eql_v3_real_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_real_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param selector text ---! @return public.eql_v3_real_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_real_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ope, selector text) RETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param selector integer ---! @return public.eql_v3_real_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_real_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ope, selector integer) RETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_real_ord_ope ---! @return public.eql_v3_real_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator +--! @return public.eql_v3_real_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_ord_ope) RETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_real_ord_ope ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b public.eql_v3_real_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_real_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_real_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b public.eql_v3_real_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_real_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$ @@ -7722,261 +9647,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) >= eql_v3.ord_term_ore(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b public.eql_v3_smallint_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_smallint_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b public.eql_v3_smallint_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_smallint_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param selector text ---! @return public.eql_v3_smallint_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_ord_ore, selector text) RETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param selector integer ---! @return public.eql_v3_smallint_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_ord_ore, selector integer) RETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_smallint_ord_ore ---! @return public.eql_v3_smallint_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint_ord_ore) RETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_smallint_ord_ore ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b public.eql_v3_smallint_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_smallint_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_smallint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b public.eql_v3_smallint_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_smallint_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$ @@ -8486,261 +10556,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_smallint_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_smallint_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param selector text ---! @return public.eql_v3_smallint_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_ord_ope, selector text) RETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param selector integer ---! @return public.eql_v3_smallint_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_ord_ope, selector integer) RETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_smallint_ord_ope ---! @return public.eql_v3_smallint_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint_ord_ope) RETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_smallint_ord_ope ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_smallint_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_smallint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_smallint_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$ @@ -8903,261 +11118,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b public.eql_v3_smallint_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a jsonb ---! @param b public.eql_v3_smallint_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b public.eql_v3_smallint_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a jsonb ---! @param b public.eql_v3_smallint_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param selector text ---! @return public.eql_v3_smallint_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_smallint_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_ord, selector text) RETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param selector integer ---! @return public.eql_v3_smallint_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_smallint_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_ord, selector integer) RETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a jsonb ---! @param selector public.eql_v3_smallint_ord ---! @return public.eql_v3_smallint_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator +--! @return public.eql_v3_smallint_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint_ord) RETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a jsonb ---! @param selector public.eql_v3_smallint_ord ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint_ord) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b public.eql_v3_smallint_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a jsonb ---! @param b public.eql_v3_smallint_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_smallint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b public.eql_v3_smallint_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. ---! @param a jsonb ---! @param b public.eql_v3_smallint_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$ @@ -9320,423 +11680,658 @@ AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; --! @brief Functions for public.eql_v3_smallint. --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param selector text ---! @return public.eql_v3_smallint +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_smallint never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint, selector text) RETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param selector integer ---! @return public.eql_v3_smallint +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_smallint never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint, selector integer) RETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param selector public.eql_v3_smallint ---! @return public.eql_v3_smallint +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_smallint right operand of the blocked operator +--! @return public.eql_v3_smallint never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint) RETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param selector public.eql_v3_smallint ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_smallint right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b public.eql_v3_smallint ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint, b public.eql_v3_smallint) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a public.eql_v3_smallint ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_smallint. ---! @param a jsonb ---! @param b public.eql_v3_smallint ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_smallint right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$ @@ -10156,261 +12751,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b public.eql_v3_date_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b public.eql_v3_date_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b public.eql_v3_date_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a jsonb ---! @param b public.eql_v3_date_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b public.eql_v3_date_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b public.eql_v3_date_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b public.eql_v3_date_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a jsonb ---! @param b public.eql_v3_date_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param selector text ---! @return public.eql_v3_date_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_date_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord, selector text) RETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param selector integer ---! @return public.eql_v3_date_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_date_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord, selector integer) RETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a jsonb ---! @param selector public.eql_v3_date_ord ---! @return public.eql_v3_date_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_date_ord right operand of the blocked operator +--! @return public.eql_v3_date_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_ord) RETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a jsonb ---! @param selector public.eql_v3_date_ord ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_date_ord right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_ord) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b public.eql_v3_date_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b public.eql_v3_date_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord, b public.eql_v3_date_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a jsonb ---! @param b public.eql_v3_date_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_date_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b public.eql_v3_date_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b public.eql_v3_date_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord, b public.eql_v3_date_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord. ---! @param a jsonb ---! @param b public.eql_v3_date_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$ @@ -10771,261 +13511,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) >= eql_v3.ord_term_ore(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b public.eql_v3_date_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_date_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b public.eql_v3_date_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_date_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param selector text ---! @return public.eql_v3_date_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_date_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ore, selector text) RETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param selector integer ---! @return public.eql_v3_date_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_date_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ore, selector integer) RETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_date_ord_ore ---! @return public.eql_v3_date_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator +--! @return public.eql_v3_date_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_ord_ore) RETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_date_ord_ore ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b public.eql_v3_date_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_date_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_date_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b public.eql_v3_date_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_date_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$ @@ -11188,261 +14073,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b public.eql_v3_date_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_date_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b public.eql_v3_date_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_date_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param selector text ---! @return public.eql_v3_date_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_date_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ope, selector text) RETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param selector integer ---! @return public.eql_v3_date_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_date_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ope, selector integer) RETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_date_ord_ope ---! @return public.eql_v3_date_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator +--! @return public.eql_v3_date_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_ord_ope) RETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_date_ord_ope ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b public.eql_v3_date_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_date_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_date_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b public.eql_v3_date_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_date_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$ @@ -11509,369 +14539,574 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) <> eql_v3.eq_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a jsonb ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a jsonb ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a jsonb ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a jsonb ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a jsonb ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a jsonb ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param selector text ---! @return public.eql_v3_date_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_date_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_eq, selector text) RETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param selector integer ---! @return public.eql_v3_date_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_date_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_eq, selector integer) RETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a jsonb ---! @param selector public.eql_v3_date_eq ---! @return public.eql_v3_date_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_date_eq right operand of the blocked operator +--! @return public.eql_v3_date_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_eq) RETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a jsonb ---! @param selector public.eql_v3_date_eq ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_date_eq right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_eq) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a jsonb ---! @param b public.eql_v3_date_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_eq, b public.eql_v3_date_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date_eq. ---! @param a jsonb ---! @param b public.eql_v3_date_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$ @@ -11882,423 +15117,658 @@ LANGUAGE plpgsql; --! @brief Functions for public.eql_v3_date. --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param selector text ---! @return public.eql_v3_date +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_date never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date, selector text) RETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param selector integer ---! @return public.eql_v3_date +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_date never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date, selector integer) RETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param selector public.eql_v3_date ---! @return public.eql_v3_date +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_date right operand of the blocked operator +--! @return public.eql_v3_date never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date) RETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param selector public.eql_v3_date ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_date right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_date) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b public.eql_v3_date ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date, b public.eql_v3_date) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a public.eql_v3_date ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_date left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_date. ---! @param a jsonb ---! @param b public.eql_v3_date ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_date right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$ @@ -12969,369 +16439,574 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_numeric_eq) <> eql_v3.eq_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a jsonb ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a jsonb ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a jsonb ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a jsonb ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a jsonb ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a jsonb ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param selector text ---! @return public.eql_v3_numeric_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_numeric_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_eq, selector text) RETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param selector integer ---! @return public.eql_v3_numeric_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_numeric_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_eq, selector integer) RETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a jsonb ---! @param selector public.eql_v3_numeric_eq ---! @return public.eql_v3_numeric_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator +--! @return public.eql_v3_numeric_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric_eq) RETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a jsonb ---! @param selector public.eql_v3_numeric_eq ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric_eq) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a jsonb ---! @param b public.eql_v3_numeric_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b public.eql_v3_numeric_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. ---! @param a jsonb ---! @param b public.eql_v3_numeric_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$ @@ -13494,261 +17169,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param selector text ---! @return public.eql_v3_numeric_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_numeric_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord, selector text) RETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param selector integer ---! @return public.eql_v3_numeric_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_numeric_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord, selector integer) RETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param selector public.eql_v3_numeric_ord ---! @return public.eql_v3_numeric_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator +--! @return public.eql_v3_numeric_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric_ord) RETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param selector public.eql_v3_numeric_ord ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric_ord) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_numeric_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b public.eql_v3_numeric_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$ @@ -14019,261 +17839,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) >= eql_v3.ord_term_ore(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param selector text ---! @return public.eql_v3_numeric_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ore, selector text) RETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param selector integer ---! @return public.eql_v3_numeric_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ore, selector integer) RETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_numeric_ord_ore ---! @return public.eql_v3_numeric_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric_ord_ore) RETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_numeric_ord_ore ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$ @@ -14544,261 +18509,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param selector text ---! @return public.eql_v3_numeric_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ope, selector text) RETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param selector integer ---! @return public.eql_v3_numeric_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ope, selector integer) RETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_numeric_ord_ope ---! @return public.eql_v3_numeric_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric_ord_ope) RETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_numeric_ord_ope ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$ @@ -15456,423 +19566,658 @@ $$; --! @brief Functions for public.eql_v3_json. --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a jsonb ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a jsonb ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a jsonb ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a jsonb ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a jsonb ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a jsonb ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a jsonb ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a jsonb ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param selector text ---! @return public.eql_v3_json +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_json never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_json, selector text) RETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param selector integer ---! @return public.eql_v3_json +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_json never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_json, selector integer) RETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a jsonb ---! @param selector public.eql_v3_json ---! @return public.eql_v3_json +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_json right operand of the blocked operator +--! @return public.eql_v3_json never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_json) RETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_json, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_json, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a jsonb ---! @param selector public.eql_v3_json ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_json right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_json) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_json, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_json, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_json, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_json, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_json, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a jsonb ---! @param b public.eql_v3_json ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_json) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_json, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_json, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_json, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_json, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_json, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_json, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_json, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b public.eql_v3_json ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_json, b public.eql_v3_json) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a public.eql_v3_json ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_json left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_json, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_json. ---! @param a jsonb ---! @param b public.eql_v3_json ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_json right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_json) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$ @@ -16125,261 +20470,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b public.eql_v3_double_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b public.eql_v3_double_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord, b public.eql_v3_double_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a jsonb ---! @param b public.eql_v3_double_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b public.eql_v3_double_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b public.eql_v3_double_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord, b public.eql_v3_double_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a jsonb ---! @param b public.eql_v3_double_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param selector text ---! @return public.eql_v3_double_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_double_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord, selector text) RETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param selector integer ---! @return public.eql_v3_double_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_double_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord, selector integer) RETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a jsonb ---! @param selector public.eql_v3_double_ord ---! @return public.eql_v3_double_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_double_ord right operand of the blocked operator +--! @return public.eql_v3_double_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double_ord) RETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a jsonb ---! @param selector public.eql_v3_double_ord ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_double_ord right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double_ord) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b public.eql_v3_double_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b public.eql_v3_double_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord, b public.eql_v3_double_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a jsonb ---! @param b public.eql_v3_double_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_double_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b public.eql_v3_double_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b public.eql_v3_double_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord, b public.eql_v3_double_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord. ---! @param a jsonb ---! @param b public.eql_v3_double_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$ @@ -16542,261 +21032,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) >= eql_v3.ord_term_ore(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b public.eql_v3_double_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_double_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b public.eql_v3_double_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_double_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param selector text ---! @return public.eql_v3_double_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_double_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord_ore, selector text) RETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param selector integer ---! @return public.eql_v3_double_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_double_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord_ore, selector integer) RETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_double_ord_ore ---! @return public.eql_v3_double_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator +--! @return public.eql_v3_double_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double_ord_ore) RETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_double_ord_ore ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b public.eql_v3_double_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_double_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_double_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b public.eql_v3_double_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_double_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$ @@ -16959,261 +21594,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b public.eql_v3_double_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_double_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b public.eql_v3_double_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_double_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param selector text ---! @return public.eql_v3_double_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_double_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord_ope, selector text) RETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param selector integer ---! @return public.eql_v3_double_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_double_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord_ope, selector integer) RETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_double_ord_ope ---! @return public.eql_v3_double_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator +--! @return public.eql_v3_double_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double_ord_ope) RETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_double_ord_ope ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b public.eql_v3_double_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_double_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_double_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b public.eql_v3_double_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_double_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$ @@ -17738,423 +22518,658 @@ CREATE OPERATOR || ( --! @brief Functions for public.eql_v3_double. --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param selector text ---! @return public.eql_v3_double +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_double never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double, selector text) RETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param selector integer ---! @return public.eql_v3_double +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_double never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double, selector integer) RETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param selector public.eql_v3_double ---! @return public.eql_v3_double +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_double right operand of the blocked operator +--! @return public.eql_v3_double never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double) RETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param selector public.eql_v3_double ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_double right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_double) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b public.eql_v3_double ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double, b public.eql_v3_double) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a public.eql_v3_double ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_double left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_double. ---! @param a jsonb ---! @param b public.eql_v3_double ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_double right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$ @@ -18522,369 +23537,574 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) <> eql_v3.eq_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param selector text ---! @return public.eql_v3_integer_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_integer_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_eq, selector text) RETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param selector integer ---! @return public.eql_v3_integer_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_integer_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_eq, selector integer) RETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param selector public.eql_v3_integer_eq ---! @return public.eql_v3_integer_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_integer_eq right operand of the blocked operator +--! @return public.eql_v3_integer_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_eq) RETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param selector public.eql_v3_integer_eq ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_integer_eq right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_eq) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_eq. ---! @param a jsonb ---! @param b public.eql_v3_integer_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$ @@ -19047,261 +24267,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b public.eql_v3_integer_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b public.eql_v3_integer_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a jsonb ---! @param b public.eql_v3_integer_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b public.eql_v3_integer_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b public.eql_v3_integer_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a jsonb ---! @param b public.eql_v3_integer_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param selector text ---! @return public.eql_v3_integer_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_integer_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord, selector text) RETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param selector integer ---! @return public.eql_v3_integer_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_integer_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord, selector integer) RETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a jsonb ---! @param selector public.eql_v3_integer_ord ---! @return public.eql_v3_integer_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_integer_ord right operand of the blocked operator +--! @return public.eql_v3_integer_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_ord) RETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a jsonb ---! @param selector public.eql_v3_integer_ord ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_integer_ord right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_ord) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b public.eql_v3_integer_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b public.eql_v3_integer_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a jsonb ---! @param b public.eql_v3_integer_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_integer_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b public.eql_v3_integer_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b public.eql_v3_integer_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord. ---! @param a jsonb ---! @param b public.eql_v3_integer_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$ @@ -19721,261 +25086,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) >= eql_v3.ord_term_ore(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_integer_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_integer_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param selector text ---! @return public.eql_v3_integer_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_integer_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ore, selector text) RETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param selector integer ---! @return public.eql_v3_integer_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_integer_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ore, selector integer) RETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_integer_ord_ore ---! @return public.eql_v3_integer_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @return public.eql_v3_integer_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_ord_ore) RETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_integer_ord_ore ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_integer_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_integer_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$ @@ -20485,261 +25995,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_integer_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_integer_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param selector text ---! @return public.eql_v3_integer_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_integer_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ope, selector text) RETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param selector integer ---! @return public.eql_v3_integer_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_integer_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ope, selector integer) RETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_integer_ord_ope ---! @return public.eql_v3_integer_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @return public.eql_v3_integer_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_ord_ope) RETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_integer_ord_ope ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_integer_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_integer_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$ @@ -20750,423 +26405,658 @@ LANGUAGE plpgsql; --! @brief Functions for public.eql_v3_integer. --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param selector text ---! @return public.eql_v3_integer +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_integer never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer, selector text) RETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param selector integer ---! @return public.eql_v3_integer +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_integer never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer, selector integer) RETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param selector public.eql_v3_integer ---! @return public.eql_v3_integer +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_integer right operand of the blocked operator +--! @return public.eql_v3_integer never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer) RETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param selector public.eql_v3_integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b public.eql_v3_integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer, b public.eql_v3_integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a public.eql_v3_integer ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_integer left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_integer. ---! @param a jsonb ---! @param b public.eql_v3_integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$ @@ -21515,306 +27405,476 @@ LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a jsonb ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a jsonb ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a jsonb ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a jsonb ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a jsonb ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a jsonb ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a jsonb ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a jsonb ---! @param b public.eql_v3_text_match ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param selector text ---! @return public.eql_v3_text_match +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_text_match never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_match, selector text) RETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param selector integer ---! @return public.eql_v3_text_match +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_text_match never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_match, selector integer) RETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a jsonb ---! @param selector public.eql_v3_text_match ---! @return public.eql_v3_text_match +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_match right operand of the blocked operator +--! @return public.eql_v3_text_match never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_match) RETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_match, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_match, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a jsonb ---! @param selector public.eql_v3_text_match ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_match right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_match) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_match, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_match, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_match, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_match, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_match'; END; $$ @@ -21845,90 +27905,140 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_match) @> eql_v3.match_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_match, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_match, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_match, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_match, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_match, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_match, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_match, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_match, b public.eql_v3_text_match) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_match, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_match. ---! @param a jsonb ---! @param b public.eql_v3_text_match ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_match right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_match) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$ @@ -22099,261 +28209,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b public.eql_v3_text_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b public.eql_v3_text_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param selector text ---! @return public.eql_v3_text_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_text_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ope, selector text) RETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param selector integer ---! @return public.eql_v3_text_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_text_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ope, selector integer) RETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_text_ord_ope ---! @return public.eql_v3_text_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator +--! @return public.eql_v3_text_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_ord_ope) RETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_text_ord_ope ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b public.eql_v3_text_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_text_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b public.eql_v3_text_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$ @@ -22640,261 +28895,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) >= eql_v3.ord_term_ore(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param selector text ---! @return public.eql_v3_text_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_text_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ore, selector text) RETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param selector integer ---! @return public.eql_v3_text_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_text_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ore, selector integer) RETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_text_ord_ore ---! @return public.eql_v3_text_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator +--! @return public.eql_v3_text_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_ord_ore) RETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_text_ord_ore ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_text_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b public.eql_v3_text_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$ @@ -22961,369 +29361,574 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) <> eql_v3.eq_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a jsonb ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a jsonb ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a jsonb ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a jsonb ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a jsonb ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a jsonb ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param selector text ---! @return public.eql_v3_text_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_text_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_eq, selector text) RETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param selector integer ---! @return public.eql_v3_text_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_text_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_eq, selector integer) RETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a jsonb ---! @param selector public.eql_v3_text_eq ---! @return public.eql_v3_text_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_eq right operand of the blocked operator +--! @return public.eql_v3_text_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_eq) RETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a jsonb ---! @param selector public.eql_v3_text_eq ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_eq right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_eq) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a jsonb ---! @param b public.eql_v3_text_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_eq, b public.eql_v3_text_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_eq. ---! @param a jsonb ---! @param b public.eql_v3_text_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$ @@ -23502,144 +30107,224 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b public.eql_v3_text_search ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b public.eql_v3_text_search right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b public.eql_v3_text_search) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a jsonb ---! @param b public.eql_v3_text_search ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_search right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b public.eql_v3_text_search ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b public.eql_v3_text_search right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b public.eql_v3_text_search) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a jsonb ---! @param b public.eql_v3_text_search ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_search right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param selector text ---! @return public.eql_v3_text_search +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_text_search never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search, selector text) RETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param selector integer ---! @return public.eql_v3_text_search +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_text_search never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search, selector integer) RETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a jsonb ---! @param selector public.eql_v3_text_search ---! @return public.eql_v3_text_search +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_search right operand of the blocked operator +--! @return public.eql_v3_text_search never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_search) RETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a jsonb ---! @param selector public.eql_v3_text_search ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_search right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_search) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_search, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_search, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_search, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_search, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search'; END; $$ @@ -23670,90 +30355,140 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search) @> eql_v3.match_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_search, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_search, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_search, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_search, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b public.eql_v3_text_search ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b public.eql_v3_text_search right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search, b public.eql_v3_text_search) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search. ---! @param a jsonb ---! @param b public.eql_v3_text_search ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_search right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_search) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$ @@ -23932,144 +30667,224 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) >= eql_v3.ord_term_ore(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b public.eql_v3_text_search_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b public.eql_v3_text_search_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_search_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_search_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b public.eql_v3_text_search_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b public.eql_v3_text_search_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_search_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_search_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param selector text ---! @return public.eql_v3_text_search_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_text_search_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search_ore, selector text) RETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param selector integer ---! @return public.eql_v3_text_search_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_text_search_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search_ore, selector integer) RETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a jsonb ---! @param selector public.eql_v3_text_search_ore ---! @return public.eql_v3_text_search_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator +--! @return public.eql_v3_text_search_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_search_ore) RETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a jsonb ---! @param selector public.eql_v3_text_search_ore ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_search_ore) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_search_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_search_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_search_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_search_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search_ore'; END; $$ @@ -24100,90 +30915,140 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search_ore) @> eql_v3.match_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_search_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_search_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_search_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_search_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b public.eql_v3_text_search_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b public.eql_v3_text_search_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. ---! @param a jsonb ---! @param b public.eql_v3_text_search_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text_search_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_search_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$ @@ -24860,261 +31725,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) >= eql_v3.ord_term_ore(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param selector text ---! @return public.eql_v3_timestamp_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ore, selector text) RETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param selector integer ---! @return public.eql_v3_timestamp_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ore, selector integer) RETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_timestamp_ord_ore ---! @return public.eql_v3_timestamp_ord_ore +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_ord_ore) RETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a jsonb ---! @param selector public.eql_v3_timestamp_ord_ore ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ore ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_timestamp_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ore ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$ @@ -25277,261 +32287,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b public.eql_v3_timestamp_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b public.eql_v3_timestamp_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param selector text ---! @return public.eql_v3_timestamp_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_timestamp_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord, selector text) RETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param selector integer ---! @return public.eql_v3_timestamp_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_timestamp_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord, selector integer) RETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a jsonb ---! @param selector public.eql_v3_timestamp_ord ---! @return public.eql_v3_timestamp_ord +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator +--! @return public.eql_v3_timestamp_ord never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_ord) RETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a jsonb ---! @param selector public.eql_v3_timestamp_ord ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_ord) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b public.eql_v3_timestamp_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_ord ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_timestamp_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b public.eql_v3_timestamp_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_ord ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$ @@ -25995,261 +33150,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param selector text ---! @return public.eql_v3_timestamp_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ope, selector text) RETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param selector integer ---! @return public.eql_v3_timestamp_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ope, selector integer) RETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_timestamp_ord_ope ---! @return public.eql_v3_timestamp_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_ord_ope) RETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_timestamp_ord_ope ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$ @@ -27506,7 +34806,7 @@ DROP FUNCTION IF EXISTS eql_v3.version(); --! @brief EQL version reporting (self-contained eql_v3 surface) --! --! This file is auto-generated from src/v3/version.template during build. ---! The 3.0.0 placeholder is replaced with the actual release +--! The 3.0.1-alpha.0 placeholder is replaced with the actual release --! version (bare semver, e.g. "3.0.0") supplied via `mise run build --version`, --! or "DEV" for development builds. @@ -27525,14 +34825,14 @@ CREATE FUNCTION eql_v3.version() RETURNS text IMMUTABLE STRICT PARALLEL SAFE AS $$ - SELECT '3.0.0'; + SELECT '3.0.1-alpha.0'; $$ LANGUAGE SQL; --! @brief Schema-level version marker for obj_description() discoverability --! --! Mirrors eql_v3.version() as a comment on the schema so the installed --! version can also be read via obj_description('eql_v3'::regnamespace). -COMMENT ON SCHEMA eql_v3 IS '3.0.0'; +COMMENT ON SCHEMA eql_v3 IS '3.0.1-alpha.0'; --! @brief EQL lint: detect non-inlinable operator implementation functions --! @@ -28234,369 +35534,574 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) <> eql_v3.eq_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a jsonb ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a jsonb ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a jsonb ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a jsonb ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a jsonb ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a jsonb ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param selector text ---! @return public.eql_v3_bigint_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_bigint_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_eq, selector text) RETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param selector integer ---! @return public.eql_v3_bigint_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_bigint_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_eq, selector integer) RETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a jsonb ---! @param selector public.eql_v3_bigint_eq ---! @return public.eql_v3_bigint_eq +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator +--! @return public.eql_v3_bigint_eq never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_eq) RETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a jsonb ---! @param selector public.eql_v3_bigint_eq ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_eq) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a jsonb ---! @param b public.eql_v3_bigint_eq ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. ---! @param a jsonb ---! @param b public.eql_v3_bigint_eq ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$ @@ -28911,261 +36416,406 @@ RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) >= eql_v3.ord_term(b) $$; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param selector text ---! @return public.eql_v3_bigint_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ope, selector text) RETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param selector integer ---! @return public.eql_v3_bigint_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ope, selector integer) RETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_bigint_ord_ope ---! @return public.eql_v3_bigint_ord_ope +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_ord_ope) RETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param selector public.eql_v3_bigint_ord_ope ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ope ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_bigint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. ---! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ope ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$ @@ -31333,423 +38983,658 @@ CREATE OPERATOR >= ( --! @brief Functions for public.eql_v3_real. --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a jsonb ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a jsonb ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a jsonb ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a jsonb ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a jsonb ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a jsonb ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a jsonb ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a jsonb ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param selector text ---! @return public.eql_v3_real +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_real never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real, selector text) RETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param selector integer ---! @return public.eql_v3_real +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_real never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real, selector integer) RETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a jsonb ---! @param selector public.eql_v3_real ---! @return public.eql_v3_real +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_real right operand of the blocked operator +--! @return public.eql_v3_real never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real) RETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a jsonb ---! @param selector public.eql_v3_real ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_real right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a jsonb ---! @param b public.eql_v3_real ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_real) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b public.eql_v3_real ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real, b public.eql_v3_real) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a public.eql_v3_real ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_real left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_real. ---! @param a jsonb ---! @param b public.eql_v3_real ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_real right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$ @@ -35450,423 +43335,658 @@ CREATE OPERATOR >= ( --! @brief Functions for public.eql_v3_numeric. --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param selector text ---! @return public.eql_v3_numeric +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_numeric never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric, selector text) RETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param selector integer ---! @return public.eql_v3_numeric +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_numeric never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric, selector integer) RETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param selector public.eql_v3_numeric ---! @return public.eql_v3_numeric +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_numeric right operand of the blocked operator +--! @return public.eql_v3_numeric never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric) RETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param selector public.eql_v3_numeric ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_numeric right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b public.eql_v3_numeric ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric, b public.eql_v3_numeric) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a public.eql_v3_numeric ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_numeric. ---! @param a jsonb ---! @param b public.eql_v3_numeric ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_numeric right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$ @@ -37160,423 +45280,658 @@ $$; --! @brief Functions for public.eql_v3_boolean. --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param selector text ---! @return public.eql_v3_boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_boolean, selector text) RETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param selector integer ---! @return public.eql_v3_boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_boolean, selector integer) RETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param selector public.eql_v3_boolean ---! @return public.eql_v3_boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_boolean right operand of the blocked operator +--! @return public.eql_v3_boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_boolean) RETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_boolean, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_boolean, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param selector public.eql_v3_boolean ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_boolean right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_boolean) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_boolean, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_boolean, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_boolean, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_boolean, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_boolean, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_boolean, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_boolean, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_boolean, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_boolean, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_boolean, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_boolean, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_boolean, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_boolean, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b public.eql_v3_boolean ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_boolean, b public.eql_v3_boolean) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a public.eql_v3_boolean ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_boolean, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_boolean. ---! @param a jsonb ---! @param b public.eql_v3_boolean ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_boolean right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_boolean) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$ @@ -40719,423 +49074,658 @@ AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; --! @brief Functions for public.eql_v3_text. --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a jsonb ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a jsonb ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a jsonb ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a jsonb ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a jsonb ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a jsonb ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a jsonb ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a jsonb ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param selector text ---! @return public.eql_v3_text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text, selector text) RETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param selector integer ---! @return public.eql_v3_text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text, selector integer) RETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a jsonb ---! @param selector public.eql_v3_text ---! @return public.eql_v3_text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text right operand of the blocked operator +--! @return public.eql_v3_text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text) RETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a jsonb ---! @param selector public.eql_v3_text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a jsonb ---! @param b public.eql_v3_text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b public.eql_v3_text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text, b public.eql_v3_text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a public.eql_v3_text ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_text left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_text. ---! @param a jsonb ---! @param b public.eql_v3_text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$ @@ -43943,423 +52533,658 @@ CREATE OPERATOR @@ ( --! @brief Functions for public.eql_v3_timestamp. --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a jsonb ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a jsonb ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a jsonb ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a jsonb ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a jsonb ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a jsonb ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a jsonb ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a jsonb ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param selector text ---! @return public.eql_v3_timestamp +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return public.eql_v3_timestamp never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp, selector text) RETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param selector integer ---! @return public.eql_v3_timestamp +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return public.eql_v3_timestamp never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp, selector integer) RETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a jsonb ---! @param selector public.eql_v3_timestamp ---! @return public.eql_v3_timestamp +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_timestamp right operand of the blocked operator +--! @return public.eql_v3_timestamp never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp) RETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param selector text ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param selector text right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp, selector text) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param selector integer ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param selector integer right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a jsonb ---! @param selector public.eql_v3_timestamp ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param selector public.eql_v3_timestamp right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b text ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b text[] ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b jsonb ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a jsonb ---! @param b public.eql_v3_timestamp ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b jsonpath ---! @return boolean +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b jsonpath right operand of the blocked operator +--! @return boolean never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b text[] ---! @return text +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return text never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b text ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b text right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b integer ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b integer right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b text[] ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b text[] right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b public.eql_v3_timestamp ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp, b public.eql_v3_timestamp) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a public.eql_v3_timestamp ---! @param b jsonb ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param b jsonb right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$ LANGUAGE plpgsql; --! @brief Unsupported operator blocker for public.eql_v3_timestamp. ---! @param a jsonb ---! @param b public.eql_v3_timestamp ---! @return jsonb +--! +--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! it never returns a value. The declared signature exists only so the operator +--! resolves to this blocker instead of a base-type fallback. +--! +--! @param a jsonb left operand of the blocked operator +--! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @return jsonb never returned — the function always raises "operator not supported" CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp) RETURNS jsonb IMMUTABLE PARALLEL SAFE AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$ diff --git a/packages/eql/sql/release-manifest.json b/packages/eql/sql/release-manifest.json index b27c45e21..635e57c3e 100644 --- a/packages/eql/sql/release-manifest.json +++ b/packages/eql/sql/release-manifest.json @@ -1,6 +1,6 @@ { - "eqlVersion": "3.0.0", + "eqlVersion": "3.0.1-alpha.0", "schemaVersion": 3, - "installSqlSha256": "6da5ed462b02f53a0636d783880533496eecfb52218d718791085376bc44c6a0", + "installSqlSha256": "8e3321fb74e3bef2881cdbe6dc0b94742c7192360b9e94742177794f9476c597", "uninstallSqlSha256": "b1b5131b8175c5d04da9ada108d25c81c5772b15fad79a6c419ebb32d18c60a9" } diff --git a/packages/eql/src/generated/release-manifest.ts b/packages/eql/src/generated/release-manifest.ts index b6e81c7a0..d1b84f0d1 100644 --- a/packages/eql/src/generated/release-manifest.ts +++ b/packages/eql/src/generated/release-manifest.ts @@ -1,6 +1,6 @@ export const releaseManifest = { - eqlVersion: '3.0.0', + eqlVersion: '3.0.1-alpha.0', schemaVersion: 3, - installSqlSha256: '6da5ed462b02f53a0636d783880533496eecfb52218d718791085376bc44c6a0', + installSqlSha256: '8e3321fb74e3bef2881cdbe6dc0b94742c7192360b9e94742177794f9476c597', uninstallSqlSha256: 'b1b5131b8175c5d04da9ada108d25c81c5772b15fad79a6c419ebb32d18c60a9', } as const From 0d874035e269b4bbc09a17ecc7dacebe658adde8 Mon Sep 17 00:00:00 2001 From: James Sadler Date: Tue, 14 Jul 2026 14:46:49 +1000 Subject: [PATCH 15/19] docs(eql_v3): fix stale/inverted CLLW-OPE migration comments (CIP-3490) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The blanket ord_term→ord_term_ore rename and the _ord→Term::Ope flip swept up the domains that moved *to* OPE, inverting their descriptions. A maintainer reading these would "fix" a test in the wrong direction. Corrected against the catalog ground truth across the shipped Doxygen block, test comments, the v3.0 upgrade guide, the privilege test, and the matrix-snapshot tooling. - ope_cllw/types.sql: `op` appears on `_ord` and `_ord_ope`; contrast the removed ore_cllw (`oc`) with the live ore_block_256 (`ob`). Regenerated the bundled SQL (crates/eql-bindings/sql, packages/eql/sql) via the release prepare script + GNU tsort at version 3.0.0, refreshing the release-manifest SHA256s; the installer SQL is byte-identical apart from this comment. - fixture_oracle / scalar_domains / matrix: text_search is [Hm,Ope,Bloom]; SteVec entries order by `op` not `oc`; ord identity is per-twin (ord_term/`op` for OPE, ord_term_ore/`ob` for ORE); text fixture spec is [Unique,Ore,Match,Ope]. - v3.0.md: U-note cross-links _ord→U-005, text_search→U-006. - v3_privilege_tests: ORD_QUERY now describes the OPE path (ord_term → ope_cllw) and drops the dead `GRANT USAGE ON SCHEMA extensions` — the default `_ord` path is native bytea compare and never calls pgcrypto. - mise.toml / snapshots: drop the inert `routes_through_ordering_term` grep alternative (every such test name already matches `_ord`). - known_failure: public.double_eq → public.eql_v3_double_eq (CIP-3472 prefix). --- .../eql-bindings/sql/cipherstash-encrypt.sql | 11 ++++---- crates/eql-bindings/sql/release-manifest.json | 2 +- docs/upgrading/v3.0.md | 2 +- mise.toml | 14 +++++------ packages/eql/sql/cipherstash-encrypt.sql | 11 ++++---- packages/eql/sql/release-manifest.json | 2 +- .../eql/src/generated/release-manifest.ts | 2 +- src/v3/sem/ope_cllw/types.sql | 11 ++++---- tests/sqlx/snapshots/README.md | 6 ++--- tests/sqlx/src/known_failure.rs | 2 +- tests/sqlx/src/matrix.rs | 4 +-- tests/sqlx/src/scalar_domains.rs | 9 ++++--- .../property/fixture_oracle.rs | 24 ++++++++++-------- tests/sqlx/tests/v3_privilege_tests.rs | 25 +++++++++---------- 14 files changed, 65 insertions(+), 60 deletions(-) diff --git a/crates/eql-bindings/sql/cipherstash-encrypt.sql b/crates/eql-bindings/sql/cipherstash-encrypt.sql index 4e5e70bf0..2ea867505 100644 --- a/crates/eql-bindings/sql/cipherstash-encrypt.sql +++ b/crates/eql-bindings/sql/cipherstash-encrypt.sql @@ -82,8 +82,8 @@ $$; --! --! Domain type representing a CLLW (Copyless Logarithmic Width) --! Order-Preserving Encryption term. The ciphertext is stored hex-encoded in ---! the `op` field of encrypted scalar payloads (the `_ord_ope` domains); the ---! domain carries the hex-decoded bytes. +--! the `op` field of encrypted scalar payloads (the `_ord` / `_ord_ope` +--! domains); the domain carries the hex-decoded bytes. --! --! A DOMAIN over bytea, not a composite: the OPE ciphertext is --! order-preserving under plain byte comparison, so the domain inherits @@ -92,11 +92,12 @@ $$; --! same pattern as eql_v3_internal.hmac_256 over text). That keeps the whole --! comparison chain inlinable, so a functional btree index on --! `eql_v3.ord_term(col)` engages structurally for the `_ord` / `_ord_ope` ---! domains' comparison operators. Contrast eql_v3_internal.ore_cllw (`oc`), the SteVec ---! CLLW-*ORE* composite compared by a custom per-byte protocol. +--! domains' comparison operators. Contrast eql_v3_internal.ore_block_256 (`ob`), +--! the block-ORE term behind the `_ord_ore` escape hatch, compared by a custom +--! N-block protocol. --! --! @note Transient type used only during query execution. ---! @see eql_v3_internal.ope_cllw +--! @see eql_v3_internal.ore_block_256 CREATE DOMAIN eql_v3_internal.ope_cllw AS bytea; --! @file v3/sem/ore_block_256/types.sql diff --git a/crates/eql-bindings/sql/release-manifest.json b/crates/eql-bindings/sql/release-manifest.json index 635e57c3e..6b9f303e6 100644 --- a/crates/eql-bindings/sql/release-manifest.json +++ b/crates/eql-bindings/sql/release-manifest.json @@ -1,6 +1,6 @@ { "eqlVersion": "3.0.1-alpha.0", "schemaVersion": 3, - "installSqlSha256": "8e3321fb74e3bef2881cdbe6dc0b94742c7192360b9e94742177794f9476c597", + "installSqlSha256": "008df0646aa27d66524d5acc89f5b66845f4de457e5876ed4949be7c97634dc6", "uninstallSqlSha256": "b1b5131b8175c5d04da9ada108d25c81c5772b15fad79a6c419ebb32d18c60a9" } diff --git a/docs/upgrading/v3.0.md b/docs/upgrading/v3.0.md index 4c90f651f..944ab6ddc 100644 --- a/docs/upgrading/v3.0.md +++ b/docs/upgrading/v3.0.md @@ -149,7 +149,7 @@ capability-detects the skip and **poisons every ORE-carrying domain** — `_ord_ore` on each ordered scalar family, `text_search_ore`, and their `eql_v3.query_*` twins — with an always-raising `CHECK` constraint. The set is derived from the catalog, so it shrinks automatically as -families move off block-ORE: `_ord` (see U-004) and `text_search` (see U-005) are +families move off block-ORE: `_ord` (see U-005) and `text_search` (see U-006) are CLLW-OPE-backed and are **not** poisoned. The first value cast or inserted into one (including `NULL`) raises `feature_not_supported` (SQLSTATE `0A000`) naming the domain, with a `HINT` listing the same family's platform-supported alternatives. The diff --git a/mise.toml b/mise.toml index 30cf4008d..bb3ed2e1c 100644 --- a/mise.toml +++ b/mise.toml @@ -336,7 +336,7 @@ run = """ # (snapshots/matrix_tests.txt) pins the set of macro-emitted matrix test names # for the ORDERED scalar shape. The second (snapshots/matrix_tests_eq_only.txt) # is the equality-only shape: an eq-only type's name set is exactly the ordered -# set MINUS the ord-only lines (`_ord`/`order_by`/`routes_through_ordering_term`), so it is +# set MINUS the ord-only lines (`_ord`/`order_by`), so it is # DERIVED from the one baseline — but it is also committed and PINNED: the gate # re-derives the subset at runtime and asserts it equals the committed file # (step 3 below), so a change to the baseline or the strip filter that alters the @@ -394,14 +394,14 @@ discovered=$(printf '%s\\n' "$listing" \ # An equality-only type (no `_ord` domain) emits a strict SUBSET of the # canonical (ordered) snapshot: the same names minus every ord-only line -# (`_ord` / `order_by` / `routes_through_ordering_term`). Derive that subset once into a +# (`_ord` / `order_by`). Derive that subset once into a # file, so an equality-only scalar (e.g. timestamp) needs NO second committed # snapshot — it is validated against this derivation from the single baseline. # Materialise to a file (not a shell variable) so both shapes compare via the # same `cmp`/`diff` path: a variable would strip trailing newlines on capture # and force the failure diff to reconstruct the string with `printf`. eq_only_expected="/tmp/matrix-eq-only-expected.txt" -grep -vE '_ord|order_by|routes_through_ordering_term' snapshots/matrix_tests.txt | LC_ALL=C sort -u > "$eq_only_expected" +grep -vE '_ord|order_by' snapshots/matrix_tests.txt | LC_ALL=C sort -u > "$eq_only_expected" # Pin the derivation: the runtime-derived eq-only set must equal the COMMITTED # snapshot. This closes the blind spot where the strip filter (or a new ordered @@ -411,7 +411,7 @@ grep -vE '_ord|order_by|routes_through_ordering_term' snapshots/matrix_tests.txt if ! cmp -s "$eq_only_expected" snapshots/matrix_tests_eq_only.txt; then echo "Derived eq-only set differs from committed snapshots/matrix_tests_eq_only.txt." >&2 echo "If the ordered baseline changed intentionally, regenerate the eq-only snapshot:" >&2 - echo " grep -vE '_ord|order_by|routes_through_ordering_term' snapshots/matrix_tests.txt | LC_ALL=C sort -u > snapshots/matrix_tests_eq_only.txt" >&2 + echo " grep -vE '_ord|order_by' snapshots/matrix_tests.txt | LC_ALL=C sort -u > snapshots/matrix_tests_eq_only.txt" >&2 diff snapshots/matrix_tests_eq_only.txt "$eq_only_expected" >&2 || true exit 1 fi @@ -451,7 +451,7 @@ while IFS= read -r t; do echo "Matrix test-name set for '${t}' matches NONE of the known shapes (ordered, eq-only, text, storage-only)." >&2 echo " vs ordered (snapshots/matrix_tests.txt):" >&2 diff snapshots/matrix_tests.txt "/tmp/matrix-norm-${t}.txt" >&2 || true - echo " vs derived eq-only (ordered minus _ord/order_by/routes_through_ordering_term):" >&2 + echo " vs derived eq-only (ordered minus _ord/order_by):" >&2 diff "$eq_only_expected" "/tmp/matrix-norm-${t}.txt" >&2 || true echo " vs text superset (snapshots/matrix_tests_text.txt):" >&2 diff snapshots/matrix_tests_text.txt "/tmp/matrix-norm-${t}.txt" >&2 || true @@ -515,7 +515,7 @@ run = """ # ordered → scalars::integer:: (caps = [eq, ord]) # text → scalars::text:: (caps = [eq, ord, search]; superset of ordered) # storage-only → scalars::boolean:: (caps = [storage]; term-less surface arms) -# eq-only → DERIVED from the ordered baseline (minus _ord/order_by/routes_through_ordering_term) +# eq-only → DERIVED from the ordered baseline (minus _ord/order_by) # # Out of scope by design: the sibling snapshots matrix_jsonb_entry_tests.txt and # v3_jsonb_tests.txt (driven by non-CATALOG types; regenerated by their own @@ -557,7 +557,7 @@ printf '%s\\n' "$listing" | grep '^scalars::integer::' \ # Eq-only shape: DERIVED from the freshly-regenerated ordered baseline (the # inventory gate re-derives and pins this exact relationship). -grep -vE '_ord|order_by|routes_through_ordering_term' "$stage/matrix_tests.txt" \ +grep -vE '_ord|order_by' "$stage/matrix_tests.txt" \ | LC_ALL=C sort -u > "$stage/matrix_tests_eq_only.txt" # Text shape: SUPERSET of ordered, from its own driver type. diff --git a/packages/eql/sql/cipherstash-encrypt.sql b/packages/eql/sql/cipherstash-encrypt.sql index 4e5e70bf0..2ea867505 100644 --- a/packages/eql/sql/cipherstash-encrypt.sql +++ b/packages/eql/sql/cipherstash-encrypt.sql @@ -82,8 +82,8 @@ $$; --! --! Domain type representing a CLLW (Copyless Logarithmic Width) --! Order-Preserving Encryption term. The ciphertext is stored hex-encoded in ---! the `op` field of encrypted scalar payloads (the `_ord_ope` domains); the ---! domain carries the hex-decoded bytes. +--! the `op` field of encrypted scalar payloads (the `_ord` / `_ord_ope` +--! domains); the domain carries the hex-decoded bytes. --! --! A DOMAIN over bytea, not a composite: the OPE ciphertext is --! order-preserving under plain byte comparison, so the domain inherits @@ -92,11 +92,12 @@ $$; --! same pattern as eql_v3_internal.hmac_256 over text). That keeps the whole --! comparison chain inlinable, so a functional btree index on --! `eql_v3.ord_term(col)` engages structurally for the `_ord` / `_ord_ope` ---! domains' comparison operators. Contrast eql_v3_internal.ore_cllw (`oc`), the SteVec ---! CLLW-*ORE* composite compared by a custom per-byte protocol. +--! domains' comparison operators. Contrast eql_v3_internal.ore_block_256 (`ob`), +--! the block-ORE term behind the `_ord_ore` escape hatch, compared by a custom +--! N-block protocol. --! --! @note Transient type used only during query execution. ---! @see eql_v3_internal.ope_cllw +--! @see eql_v3_internal.ore_block_256 CREATE DOMAIN eql_v3_internal.ope_cllw AS bytea; --! @file v3/sem/ore_block_256/types.sql diff --git a/packages/eql/sql/release-manifest.json b/packages/eql/sql/release-manifest.json index 635e57c3e..6b9f303e6 100644 --- a/packages/eql/sql/release-manifest.json +++ b/packages/eql/sql/release-manifest.json @@ -1,6 +1,6 @@ { "eqlVersion": "3.0.1-alpha.0", "schemaVersion": 3, - "installSqlSha256": "8e3321fb74e3bef2881cdbe6dc0b94742c7192360b9e94742177794f9476c597", + "installSqlSha256": "008df0646aa27d66524d5acc89f5b66845f4de457e5876ed4949be7c97634dc6", "uninstallSqlSha256": "b1b5131b8175c5d04da9ada108d25c81c5772b15fad79a6c419ebb32d18c60a9" } diff --git a/packages/eql/src/generated/release-manifest.ts b/packages/eql/src/generated/release-manifest.ts index d1b84f0d1..f2264194b 100644 --- a/packages/eql/src/generated/release-manifest.ts +++ b/packages/eql/src/generated/release-manifest.ts @@ -1,6 +1,6 @@ export const releaseManifest = { eqlVersion: '3.0.1-alpha.0', schemaVersion: 3, - installSqlSha256: '8e3321fb74e3bef2881cdbe6dc0b94742c7192360b9e94742177794f9476c597', + installSqlSha256: '008df0646aa27d66524d5acc89f5b66845f4de457e5876ed4949be7c97634dc6', uninstallSqlSha256: 'b1b5131b8175c5d04da9ada108d25c81c5772b15fad79a6c419ebb32d18c60a9', } as const diff --git a/src/v3/sem/ope_cllw/types.sql b/src/v3/sem/ope_cllw/types.sql index 0250d7ddc..6321969fb 100644 --- a/src/v3/sem/ope_cllw/types.sql +++ b/src/v3/sem/ope_cllw/types.sql @@ -5,8 +5,8 @@ --! --! Domain type representing a CLLW (Copyless Logarithmic Width) --! Order-Preserving Encryption term. The ciphertext is stored hex-encoded in ---! the `op` field of encrypted scalar payloads (the `_ord_ope` domains); the ---! domain carries the hex-decoded bytes. +--! the `op` field of encrypted scalar payloads (the `_ord` / `_ord_ope` +--! domains); the domain carries the hex-decoded bytes. --! --! A DOMAIN over bytea, not a composite: the OPE ciphertext is --! order-preserving under plain byte comparison, so the domain inherits @@ -15,9 +15,10 @@ --! same pattern as eql_v3_internal.hmac_256 over text). That keeps the whole --! comparison chain inlinable, so a functional btree index on --! `eql_v3.ord_term(col)` engages structurally for the `_ord` / `_ord_ope` ---! domains' comparison operators. Contrast eql_v3_internal.ore_cllw (`oc`), the SteVec ---! CLLW-*ORE* composite compared by a custom per-byte protocol. +--! domains' comparison operators. Contrast eql_v3_internal.ore_block_256 (`ob`), +--! the block-ORE term behind the `_ord_ore` escape hatch, compared by a custom +--! N-block protocol. --! --! @note Transient type used only during query execution. ---! @see eql_v3_internal.ope_cllw +--! @see eql_v3_internal.ore_block_256 CREATE DOMAIN eql_v3_internal.ope_cllw AS bytea; diff --git a/tests/sqlx/snapshots/README.md b/tests/sqlx/snapshots/README.md index bcf87b393..7a15abfaa 100644 --- a/tests/sqlx/snapshots/README.md +++ b/tests/sqlx/snapshots/README.md @@ -37,7 +37,7 @@ For equality-only types there is a second committed snapshot, `matrix_tests_eq_only.txt`. An eq-only scalar (`scalar_matrix! { caps = [eq] }`, e.g. `timestamp`) emits exactly the ordered name set MINUS the ord-only lines, so this file is **derived** from `matrix_tests.txt` (minus every line matching -`_ord` / `order_by` / `routes_through_ordering_term`) — but it is committed and pinned: the +`_ord` / `order_by`) — but it is committed and pinned: the inventory gate re-derives the set at runtime and asserts it equals this committed file, so a change to the ordered baseline or the strip filter that alters the eq-only set fails until the snapshot is deliberately regenerated. @@ -46,7 +46,7 @@ Eq-only types are then matched against the committed snapshot. The shape. Regenerate the eq-only snapshot with: ```bash -grep -vE '_ord|order_by|routes_through_ordering_term' snapshots/matrix_tests.txt | LC_ALL=C sort -u > snapshots/matrix_tests_eq_only.txt +grep -vE '_ord|order_by' snapshots/matrix_tests.txt | LC_ALL=C sort -u > snapshots/matrix_tests_eq_only.txt ``` For the **text** shape there is a third committed snapshot, @@ -118,7 +118,7 @@ The task (`mise.toml`, `[tasks."test:matrix:inventory"]`): (the `scalars::::` prefixes) — never a directory glob. 3. Normalizes each type's token to `` and asserts that type's set equals the canonical `matrix_tests.txt` (ordered shape), the derived eq-only subset - (`matrix_tests.txt` minus `_ord`/`order_by`/`routes_through_ordering_term`), the + (`matrix_tests.txt` minus `_ord`/`order_by`), the committed `matrix_tests_text.txt` superset (text shape), or the committed `matrix_tests_storage_only.txt` set (storage-only shape). Prints each type's resolved shape (`ordered` / `eq_only` / `text` / `storage_only`). Asserts at diff --git a/tests/sqlx/src/known_failure.rs b/tests/sqlx/src/known_failure.rs index 9dfa89864..c0cffcdc8 100644 --- a/tests/sqlx/src/known_failure.rs +++ b/tests/sqlx/src/known_failure.rs @@ -59,7 +59,7 @@ pub const ISSUE_FLOAT_SIGNED_ZERO_EQ: u64 = 387; /// ```ignore /// let equal = eq_cmp(&pool, a, b).await?; /// let want = if equal { Ok(()) } else { Err(anyhow!("encrypted `=` returned false")) }; -/// known_failure(ISSUE_FLOAT_SIGNED_ZERO_EQ, "-0.0 == +0.0 under public.double_eq", want) +/// known_failure(ISSUE_FLOAT_SIGNED_ZERO_EQ, "-0.0 == +0.0 under public.eql_v3_double_eq", want) /// ``` pub fn known_failure(issue: u64, what: &str, outcome: Result<()>) -> Result<()> { match outcome { diff --git a/tests/sqlx/src/matrix.rs b/tests/sqlx/src/matrix.rs index a70c6c378..03cdc39d6 100644 --- a/tests/sqlx/src/matrix.rs +++ b/tests/sqlx/src/matrix.rs @@ -160,7 +160,7 @@ fn collect_index_scan_nodes(value: &serde_json::Value, found: &mut Vec<(String, /// invocation shape is the same regardless of capability — only the `caps` /// marker differs. The emitted test names for an ordered type are byte-identical /// to the old `ordered_numeric_matrix!`; the eq-only name set is exactly that -/// set minus the `_ord` / `order_by` / `routes_through_ordering_term` lines. +/// set minus the `_ord` / `order_by` lines. /// /// Pivots — the comparison anchors swept by the correctness / cross-shape /// arms — are the `OrderedScalar` anchors: `min_pivot()`, `max_pivot()`, and the @@ -519,7 +519,7 @@ macro_rules! jsonb_entry_matrix { // Aggregates: eql_v3.min/max over json_entry (src/v3/json/aggregates.sql). // The aggregate leaf cases compare extrema via the ord-extractor seam // (eql_v3.ord_term for entries), so the entry min/max route through the - // `oc` (CLLW ORE) term exactly like the comparison operators. + // `op` (CLLW-OPE) term exactly like the comparison operators. $crate::__scalar_matrix_aggregate_outer! { suite = $suite, scalar = $scalar, script = $eql_type, script_path = "../../fixtures", domains = [(entry, Ord)], diff --git a/tests/sqlx/src/scalar_domains.rs b/tests/sqlx/src/scalar_domains.rs index 0d3c4c84f..078f4784b 100644 --- a/tests/sqlx/src/scalar_domains.rs +++ b/tests/sqlx/src/scalar_domains.rs @@ -1329,7 +1329,7 @@ impl Variant { /// domain for `token`, or `None` if unsupported (or `Storage`). Derived via /// `Term::extractor_for_operator` — the SAME single source codegen uses, so /// the harness routing cannot diverge from the generated SQL. For - /// `text_ord` `[Hm, Ore]`, `=` => `eql_v3.eq_term`, `<` => `eql_v3.ord_term`. + /// `text_ord` `[Hm, Ope]`, `=` => `eql_v3.eq_term`, `<` => `eql_v3.ord_term`. pub fn extractor_for_op(self, token: &str, op: &str) -> Option { Term::extractor_for_operator(self.terms_for(token), op).map(|f| format!("eql_v3.{f}")) } @@ -1362,13 +1362,14 @@ pub struct ScalarDomainSpec { /// terms. Call via [`ScalarDomainSpec::ord_extractor_expr`], which supplies /// `self.variant`. pub ord_extractor: fn(Variant, &str) -> String, - /// The variant's ordering term (`Term::Ope` for `_ord`, `Term::Ore` for - /// `_ord_ore` / `_search`), or `None` when the domain is not ordered. + /// The variant's ordering term (`Term::Ope` for `_ord` / `_search`, + /// `Term::Ore` for `_ord_ore` / `_search_ore`), or `None` when the domain is + /// not ordered. /// /// Read from `CATALOG` via `T::PG_TYPE`, so it is meaningless for a SteVec /// entry view, whose `PG_TYPE` names the wrapped scalar rather than its own /// structural term (`JsonbEntryInteger` reports `Some(Term::Ope)` but orders - /// by `oc`). Only the property oracles read this field, and they are + /// by `op`). Only the property oracles read this field, and they are /// instantiated solely with real scalar types — never with an entry view. /// Use [`ScalarDomainSpec::ord_extractor_expr`], which honours the /// `ord_extractor` override, when you need the extractor itself. diff --git a/tests/sqlx/tests/encrypted_domain/property/fixture_oracle.rs b/tests/sqlx/tests/encrypted_domain/property/fixture_oracle.rs index 993594a83..410732855 100644 --- a/tests/sqlx/tests/encrypted_domain/property/fixture_oracle.rs +++ b/tests/sqlx/tests/encrypted_domain/property/fixture_oracle.rs @@ -340,7 +340,7 @@ fixture_oracle_suite!(double, eql_tests::scalar_domains::F8, ordered); // // The same fixture rows, but calling the generated `eql_v3.*` comparison // functions by name across all three overloads and asserting term-extractor -// identity (eq_term==hm / ord_term_ore==ob). Free of fresh encryption — read-only +// identity (eq_term==hm / ord_term==op / ord_term_ore==ob). Free of fresh encryption — read-only // SQL over the already-encrypted fixtures. integer is the reference family with // explicit tests; the other types go through `fixture_fn_oracle_suite!`. @@ -442,13 +442,14 @@ fixture_fn_oracle_suite!(timestamp_fn, chrono::DateTime, ordered); fixture_fn_oracle_suite!(numeric_fn, rust_decimal::Decimal, ordered); // text is bespoke rather than `fixture_fn_oracle_suite!`: its ordered domains -// carry both [Hm, Ore], so they support the FULL six comparisons (eq/neq route -// through `hm`, the four ord ops through ORE) — the generic `ordered` arm only -// runs the four ord ops on the ordered twins. text also declares `_search` -// ([Hm, Ore, Bloom]), which `Variant::Search` reaches but the generic macro -// never instantiates. The generated text fixture is encrypted with -// [Unique, Ore, Match], so its payload carries hm+ob+bf and casts cleanly to -// every text domain. The fixture rows excludes the empty string (issue #262), +// carry `hm` plus an ordering term (`Ope` for `text_ord`, `Ore` for +// `text_ord_ore`), so they support the FULL six comparisons (eq/neq route +// through `hm`, the four ord ops through the ordering term) — the generic +// `ordered` arm only runs the four ord ops on the ordered twins. text also +// declares `_search` ([Hm, Ope, Bloom]), which `Variant::Search` reaches but +// the generic macro never instantiates. The generated text fixture is encrypted +// with [Unique, Ore, Match, Ope], so its payload carries hm+ob+bf+op and casts +// cleanly to every text domain. The fixture rows excludes the empty string (issue #262), // so no generator filtering is needed here. mod text_fn { use super::*; @@ -464,7 +465,8 @@ mod text_fn { } /// `text_ord` / `text_ord_ore` — full six comparisons (eq/neq + the four ord - /// ops) plus eq_term(`hm`) + ord_term_ore(`ob`) identity on each ordered twin. + /// ops) plus eq_term(`hm`) identity on both, and each twin's ordering-term + /// identity (ord_term(`op`) for `text_ord`, ord_term_ore(`ob`) for `text_ord_ore`). #[sqlx::test] async fn ord_fn_oracle(pool: PgPool) -> Result<()> { run_fn_property::(pool, 32, |pool, c| async move { @@ -478,8 +480,8 @@ mod text_fn { .await } - /// `text_search` ([Hm, Ore, Bloom]) — the eq/ord function facets plus - /// eq_term + ord_term_ore identity (the bloom `@>`/`<@` facet is covered by the + /// `text_search` ([Hm, Ope, Bloom]) — the eq/ord function facets plus + /// eq_term + ord_term identity (the bloom `@>`/`<@` facet is covered by the /// example-based `match_smoke`, not a random oracle). #[sqlx::test] async fn search_fn_oracle(pool: PgPool) -> Result<()> { diff --git a/tests/sqlx/tests/v3_privilege_tests.rs b/tests/sqlx/tests/v3_privilege_tests.rs index ace61d42f..3129d75de 100644 --- a/tests/sqlx/tests/v3_privilege_tests.rs +++ b/tests/sqlx/tests/v3_privilege_tests.rs @@ -5,7 +5,7 @@ //! (query) role which uses the supported *operators* needs USAGE + EXECUTE on //! BOTH `eql_v3` and `eql_v3_internal` — the public wrappers/extractors inline a //! call to an `eql_v3_internal` index-term constructor (e.g. `eq_term` → -//! `eql_v3_internal.hmac_256(jsonb)`, `ord_term_ore` → `eql_v3_internal.ore_block_256`), +//! `eql_v3_internal.hmac_256(jsonb)`, `ord_term` → `eql_v3_internal.ope_cllw`), //! and aggregates dispatch into `eql_v3_internal.*_sfunc`, so granting only the //! public schema is not enough. These tests make that contract executable. //! @@ -34,11 +34,12 @@ const EQ_QUERY: &str = "SELECT count(*) FROM fixtures.eql_v3_integer \ WHERE payload::public.eql_v3_integer_eq = payload::public.eql_v3_integer_eq"; /// A real ordering query using the `<` *operator* on `integer_ord`, which dispatches -/// through `eql_v3.lt` → `eql_v3.ord_term_ore` → the `eql_v3_internal.ore_block_256` -/// constructor + comparator. NB: `ORDER BY payload::public.eql_v3_integer_ord` alone does -/// NOT work here — a bare domain has no ORE opclass, so it silently falls back to -/// built-in jsonb ordering and never crosses into `eql_v3_internal`. The `<` -/// operator is what genuinely exercises the encrypted ordering path. +/// through `eql_v3.lt` → `eql_v3.ord_term` → the `eql_v3_internal.ope_cllw` +/// constructor. NB: `ORDER BY payload::public.eql_v3_integer_ord` alone does +/// NOT work here — a bare domain sorts by its jsonb base, not the encrypted +/// ordering, so it silently falls back to built-in jsonb ordering and never +/// crosses into `eql_v3_internal`. The `<` operator (which routes through +/// `ord_term`) is what genuinely exercises the encrypted ordering path. const ORD_QUERY: &str = "SELECT count(*) FROM fixtures.eql_v3_integer a, fixtures.eql_v3_integer b \ WHERE a.payload::public.eql_v3_integer_ord < b.payload::public.eql_v3_integer_ord"; @@ -169,13 +170,11 @@ async fn runtime_role_with_both_schema_grants_can_query(pool: PgPool) -> Result< grant_fixture_access(&mut conn, &role, &["eql_v3_integer"]).await?; grant_schema(&mut conn, &role, "eql_v3").await?; grant_schema(&mut conn, &role, "eql_v3_internal").await?; - // The ORE comparison (ordering / min-max) calls pgcrypto `encrypt()`, which - // the installer places in the `extensions` schema. Resolving it needs USAGE - // on that schema too — a runtime-role prerequisite beyond the two EQL - // schemas. (USAGE only; pgcrypto's own functions default EXECUTE to PUBLIC.) - sqlx::query(&format!("GRANT USAGE ON SCHEMA extensions TO \"{role}\"")) - .execute(&mut *conn) - .await?; + // NB: no `extensions` (pgcrypto) grant is needed here. The default `_ord` + // ordering path is CLLW-OPE (`eql_v3.ord_term` → `eql_v3_internal.ope_cllw`), + // which compares hex-decoded `bytea` natively and never calls pgcrypto + // `encrypt()`. Only the by-name block-ORE variants (`_ord_ore` / + // `text_search_ore`) reach pgcrypto and would need USAGE on `extensions`. sqlx::query(&format!("SET ROLE \"{role}\"")) .execute(&mut *conn) From 4623cab2c818a8ee28393df6a5f657fb775783b1 Mon Sep 17 00:00:00 2001 From: James Sadler Date: Tue, 14 Jul 2026 17:16:45 +1000 Subject: [PATCH 16/19] test(eql_v3): close CLLW-OPE migration coverage gaps (CIP-3491) Five test fixes/additions closing coverage gaps left by the block-ORE -> CLLW-OPE migration, where a naive rename left several controls vacuous or inverted: - R2a (v3_ore_fallback_tests): re-point the superuser positive control at `_ord_ore` (ORE, poisonable) instead of `_ord` (OPE, UNPOISONABLE by construction). The old control cast the OPE domain, which can never be poisoned, so it proved nothing; the ORE domain is the meaningful "superuser install does not poison" check. - PR#392 (edge_cases): split the stale `check_rejects_payload_missing_ob` into two tests. Post-flip `_ord` is OPE and its CHECK requires `op` (not `ob`), so the old test passed for the wrong reason. Now `_ord` rejects a payload missing `op` and `_ord_ore` rejects a payload missing `ob`, each proving the domain needs its own ordering term. - T18 (float_special): parameterise the signed-zero (-0.0 vs +0.0) pins over both `real` (F4) and `double` (F8) via a local `SignedZeroPair` trait and generic per-behaviour helpers. `real` shares the crypto path but was asserted nowhere; the `known_failure` inversion is preserved per type. - R3a (fixture_oracle): add `search_ore_fn_oracle` for `Variant::SearchOre` (`text_search_ore`, [Hm, Ore, Bloom]), the ORE twin of the existing `search_fn_oracle` (`text_search`, OPE). Mirrors it exactly but exercises the block-ORE extractor (`ord_term_ore`/`ob`). - T10 (v3_privilege_tests): add `runtime_role_ope_ok_ore_needs_extensions`, pinning the pgcrypto boundary. Under identical grants (eql_v3 + eql_v3_internal + fixture, but NOT `extensions`), the CLLW-OPE `_ord` path succeeds while the block-ORE `_ord_ore` path fails at pgcrypto `encrypt()`. NOT done: R2b (adding "1.0" to NUMERIC_FIXTURES). Empirically breaks CI: "1" and "1.0" parse to the same rust_decimal value, tripping the deliberate `numeric_value_guards::fixtures_are_distinct_by_value` guard (which names this exact pair) and producing duplicate-plaintext fixture rows that break `fetch_fixture_payload`'s `fetch_one` and the numeric oracle. `cargo test -p eql-domains` passes (a false green: the catalog keys numeric fixtures by literal string), but `cargo test --lib -p eql_tests` fails. Surfaced for a decision rather than shipping a CI-breaking change. --- .../tests/encrypted_domain/float_special.rs | 196 +++++++++++++----- .../encrypted_domain/property/edge_cases.rs | 30 ++- .../property/fixture_oracle.rs | 14 ++ tests/sqlx/tests/v3_ore_fallback_tests.rs | 16 +- tests/sqlx/tests/v3_privilege_tests.rs | 80 +++++++ 5 files changed, 265 insertions(+), 71 deletions(-) diff --git a/tests/sqlx/tests/encrypted_domain/float_special.rs b/tests/sqlx/tests/encrypted_domain/float_special.rs index 5a358555f..60e2e48cc 100644 --- a/tests/sqlx/tests/encrypted_domain/float_special.rs +++ b/tests/sqlx/tests/encrypted_domain/float_special.rs @@ -25,20 +25,49 @@ use anyhow::Result; use eql_tests::fixtures::cipherstash::encrypt_store; +use eql_tests::fixtures::eql_plaintext::EqlPlaintext; use eql_tests::fixtures::index_kind::IndexKind; use eql_tests::known_failure; use eql_tests::known_failure::ISSUE_FLOAT_SIGNED_ZERO_EQ; use eql_tests::property::{connect_pool, ensure_eql_installed}; -use eql_tests::scalar_domains::F8; +use eql_tests::scalar_domains::{ScalarType, Variant, F4, F8}; use sqlx::PgPool; -/// Encrypt one batch of f64 special values into payload JSON strings, one +/// The signed-zero pair (`-0.0`, `+0.0`) for a float scalar. `SignedScalar` +/// already yields `+0.0` via `origin()`, but not `-0.0`, so this local trait +/// supplies both and lets the ±0.0 tests run over `real` (F4) as well as +/// `double` (F8) — they share the same crypto path, so both must be pinned. +trait SignedZeroPair: EqlPlaintext + ScalarType { + fn neg_zero() -> Self; + fn pos_zero() -> Self; +} + +impl SignedZeroPair for F4 { + fn neg_zero() -> Self { + F4(-0.0) + } + fn pos_zero() -> Self { + F4(0.0) + } +} + +impl SignedZeroPair for F8 { + fn neg_zero() -> Self { + F8(-0.0) + } + fn pos_zero() -> Self { + F8(0.0) + } +} + +/// Encrypt one batch of float special values into payload JSON strings, one /// ZeroKMS round trip. Mirrors `e2e_oracle::encrypt_rows` but returns only the /// payloads (these tests key on position, not plaintext). `encrypt_store` /// encrypts through cipherstash-client directly — it needs no `PgPool` — and /// returns v3-envelope payloads (converted via eql_bindings::from_v2), so -/// the casts below satisfy the `v = '3'` domain CHECKs. -async fn encrypt_specials(values: &[F8]) -> Result> { +/// the casts below satisfy the `v = '3'` domain CHECKs. Generic over the float +/// scalar so the ±0.0 tests can encrypt `real` (F4) and `double` (F8) alike. +async fn encrypt_specials(values: &[T]) -> Result> { let payloads = encrypt_store( "float_special", "payload", @@ -52,6 +81,20 @@ async fn encrypt_specials(values: &[F8]) -> Result> { Ok(payloads.into_iter().map(|p| p.to_string()).collect()) } +/// Encrypt the ±0.0 pair for the float scalar `T` in one ZeroKMS round trip, +/// returning `[payload(-0.0), payload(+0.0)]`. Shared by every ±0.0 test so each +/// runs identically over `real` and `double`. +async fn signed_zero_payloads() -> Result> { + encrypt_specials(&[T::neg_zero(), T::pos_zero()]).await +} + +/// `T`'s SQL domain for `variant` (e.g. `public.eql_v3_real_ord` / +/// `public.eql_v3_double_ord`). Lets the generic ±0.0 helpers name the right +/// per-type domain in both the cast and the failure message. +fn domain(variant: Variant) -> String { + T::sql_domain(variant) +} + /// Cast a payload literal to `public.eql_v3_double` and read it back, proving the domain /// CHECK accepts the encrypted special value. async fn cast_passes_check(pool: &PgPool, payload: &str) -> Result<()> { @@ -68,19 +111,13 @@ async fn cast_passes_check(pool: &PgPool, payload: &str) -> Result<()> { } /// Compare two payloads under an operator on `public.eql_v3_double_ord` — the default -/// ordering domain, backed by CLLW-OPE (`op`). Used to pin the discovered -/// NaN/±0/±Inf outcomes. +/// ordering domain, backed by CLLW-OPE (`op`). Used by the NaN/±Inf pins, which +/// stay `double`-only (the ±0.0 pins parameterise over `real`/`double` via +/// `cmp_on` + `domain::` instead). async fn ord_cmp(pool: &PgPool, a: &str, op: &str, b: &str) -> Result { cmp_on(pool, "public.eql_v3_double_ord", a, op, b).await } -/// The same comparison on `public.eql_v3_double_ord_ore` — the block-ORE ordering -/// domain. Kept distinct from [`ord_cmp`] because the two SEMs do not agree on -/// `-0.0` vs `+0.0` (see the module doc). -async fn ord_ore_cmp(pool: &PgPool, a: &str, op: &str, b: &str) -> Result { - cmp_on(pool, "public.eql_v3_double_ord_ore", a, op, b).await -} - async fn cmp_on(pool: &PgPool, d: &str, a: &str, op: &str, b: &str) -> Result { let sql = format!("SELECT ($1::jsonb::{d} {op} $2::jsonb::{d})"); Ok(sqlx::query_scalar(&sql) @@ -135,21 +172,46 @@ async fn two_encryptions_of_same_nan_bits_compare_equal() -> Result<()> { Ok(()) } +/// Generic body of `negative_zero_and_positive_zero_share_ore_order`, run per +/// float type: block-ORE orders `-0.0` and `+0.0` equal on `T`'s `_ord_ore`. +async fn share_ore_order(pool: &PgPool) -> Result<()> { + let d = domain::(Variant::OrdOre); + let p = signed_zero_payloads::().await?; + anyhow::ensure!( + !cmp_on(pool, &d, &p[0], "<", &p[1]).await?, + "-0.0 not < +0.0 under block-ORE ({d})" + ); + anyhow::ensure!( + !cmp_on(pool, &d, &p[1], "<", &p[0]).await?, + "+0.0 not < -0.0 under block-ORE ({d})" + ); + Ok(()) +} + #[tokio::test] async fn negative_zero_and_positive_zero_share_ore_order() -> Result<()> { // Block-ORE rides the `orderable-bytes` encoder, which canonicalizes // -0.0 -> +0.0 before encoding, so `_ord_ore` orders them equal — matching // IEEE (-0.0 == 0.0). Contrast `negative_zero_orders_below_positive_zero_ - // under_ope`: the OPE term does NOT canonicalize. + // under_ope`: the OPE term does NOT canonicalize. `real` and `double` share + // the encoder, so both are pinned. let pool = setup().await?; - let p = encrypt_specials(&[F8(-0.0), F8(0.0)]).await?; - assert!( - !ord_ore_cmp(&pool, &p[0], "<", &p[1]).await?, - "-0.0 not < +0.0 under block-ORE" + share_ore_order::(&pool).await?; + share_ore_order::(&pool).await +} + +/// Generic body of `negative_zero_orders_below_positive_zero_under_ope`, run per +/// float type: CLLW-OPE orders `-0.0 < +0.0` on `T`'s `_ord`. +async fn orders_below_under_ope(pool: &PgPool) -> Result<()> { + let d = domain::(Variant::Ord); + let p = signed_zero_payloads::().await?; + anyhow::ensure!( + cmp_on(pool, &d, &p[0], "<", &p[1]).await?, + "-0.0 < +0.0 under CLLW-OPE ({d})" ); - assert!( - !ord_ore_cmp(&pool, &p[1], "<", &p[0]).await?, - "+0.0 not < -0.0 under block-ORE" + anyhow::ensure!( + !cmp_on(pool, &d, &p[1], "<", &p[0]).await?, + "+0.0 not < -0.0 under CLLW-OPE ({d})" ); Ok(()) } @@ -161,18 +223,11 @@ async fn negative_zero_orders_below_positive_zero_under_ope() -> Result<()> { // So the OPE-backed `_ord` domain DIVERGES from IEEE here, where block-ORE // agreed with it. This is a deliberate, pinned consequence of `_ord` moving // to CLLW-OPE — a float column that must treat ±0.0 as equal for ORDER BY - // should be typed `_ord_ore`. + // should be typed `_ord_ore`. `real` and `double` share the SEM, so both are + // pinned. let pool = setup().await?; - let p = encrypt_specials(&[F8(-0.0), F8(0.0)]).await?; - assert!( - ord_cmp(&pool, &p[0], "<", &p[1]).await?, - "-0.0 < +0.0 under CLLW-OPE" - ); - assert!( - !ord_cmp(&pool, &p[1], "<", &p[0]).await?, - "+0.0 not < -0.0 under CLLW-OPE" - ); - Ok(()) + orders_below_under_ope::(&pool).await?; + orders_below_under_ope::(&pool).await } /// `-0.0` and `+0.0` are IEEE-equal, so encrypted `=` on `_eq` must agree. @@ -193,26 +248,37 @@ async fn negative_zero_orders_below_positive_zero_under_ope() -> Result<()> { /// the test, so the ORE ordering canary below it had never actually executed. /// /// [#387]: https://github.com/cipherstash/encrypt-query-language/issues/387 -#[tokio::test] -async fn negative_zero_and_positive_zero_compare_equal_under_eq() -> Result<()> { - let pool = setup().await?; - let p = encrypt_specials(&[F8(-0.0), F8(0.0)]).await?; +/// +/// Generic body of `negative_zero_and_positive_zero_compare_equal_under_eq`, run +/// per float type against `T`'s `_eq` domain (e.g. `public.eql_v3_real_eq` / +/// `public.eql_v3_double_eq`). Keeps the `known_failure` inversion intact per +/// type. +async fn eq_split(pool: &PgPool) -> Result<()> { + let d = domain::(Variant::Eq); + let p = signed_zero_payloads::().await?; - let equal = eq_cmp(&pool, &p[0], &p[1]).await?; + let equal = cmp_on(pool, &d, &p[0], "=", &p[1]).await?; let assertion = if equal { Ok(()) } else { Err(anyhow::anyhow!( - "encrypted `=` on public.eql_v3_double_eq returned false for -0.0 vs +0.0" + "encrypted `=` on {d} returned false for -0.0 vs +0.0" )) }; known_failure( ISSUE_FLOAT_SIGNED_ZERO_EQ, - "-0.0 == +0.0 under public.eql_v3_double_eq", + &format!("-0.0 == +0.0 under {d}"), assertion, ) } +#[tokio::test] +async fn negative_zero_and_positive_zero_compare_equal_under_eq() -> Result<()> { + let pool = setup().await?; + eq_split::(&pool).await?; + eq_split::(&pool).await +} + /// `=` on the OPE-backed `_ord` domain splits `±0.0` too — pinned, and pinned /// to the SAME issue as `_eq`. /// @@ -231,44 +297,64 @@ async fn negative_zero_and_positive_zero_compare_equal_under_eq() -> Result<()> /// /// Contrast [`negative_zero_and_positive_zero_compare_equal_under_ord_ore`]: /// block-ORE canonicalizes, so `=` there already agrees with IEEE and needs no -/// marker. `real` shares this SEM with `double`; one type is pinned, as -/// everywhere else in this module. +/// marker. `real` shares this SEM with `double`; both are pinned, as everywhere +/// else in this module. /// /// [#387]: https://github.com/cipherstash/encrypt-query-language/issues/387 -#[tokio::test] -async fn negative_zero_and_positive_zero_compare_equal_under_ord() -> Result<()> { - let pool = setup().await?; - let p = encrypt_specials(&[F8(-0.0), F8(0.0)]).await?; +/// +/// Generic body of `negative_zero_and_positive_zero_compare_equal_under_ord`, +/// run per float type against `T`'s OPE-backed `_ord` domain. Keeps the +/// `known_failure` inversion intact per type. +async fn ord_split(pool: &PgPool) -> Result<()> { + let d = domain::(Variant::Ord); + let p = signed_zero_payloads::().await?; - let equal = ord_cmp(&pool, &p[0], "=", &p[1]).await?; + let equal = cmp_on(pool, &d, &p[0], "=", &p[1]).await?; let assertion = if equal { Ok(()) } else { Err(anyhow::anyhow!( - "encrypted `=` on public.eql_v3_double_ord returned false for -0.0 vs +0.0" + "encrypted `=` on {d} returned false for -0.0 vs +0.0" )) }; known_failure( ISSUE_FLOAT_SIGNED_ZERO_EQ, - "-0.0 == +0.0 under public.eql_v3_double_ord", + &format!("-0.0 == +0.0 under {d}"), assertion, ) } +#[tokio::test] +async fn negative_zero_and_positive_zero_compare_equal_under_ord() -> Result<()> { + let pool = setup().await?; + ord_split::(&pool).await?; + ord_split::(&pool).await +} + +/// Generic body of `negative_zero_and_positive_zero_compare_equal_under_ord_ore`, +/// run per float type: `=` on `T`'s block-ORE `_ord_ore` agrees with IEEE. +async fn ord_ore_equal(pool: &PgPool) -> Result<()> { + let d = domain::(Variant::OrdOre); + let p = signed_zero_payloads::().await?; + anyhow::ensure!( + cmp_on(pool, &d, &p[0], "=", &p[1]).await?, + "-0.0 = +0.0 under block-ORE `_ord_ore` \ + (orderable-bytes canonicalizes the sign of zero) ({d})" + ); + Ok(()) +} + /// `=` on the block-ORE `_ord_ore` domain agrees with IEEE: the /// `orderable-bytes` encoder canonicalizes `-0.0 -> +0.0` before encoding, so /// both zeroes share one `ob` term. Asserted unconditionally — this is the /// behaviour `_ord` had before the CLLW-OPE flip, and the reason a float column -/// needing IEEE `±0.0` semantics should be typed `_ord_ore`. +/// needing IEEE `±0.0` semantics should be typed `_ord_ore`. `real` and `double` +/// share the encoder, so both are pinned. #[tokio::test] async fn negative_zero_and_positive_zero_compare_equal_under_ord_ore() -> Result<()> { let pool = setup().await?; - let p = encrypt_specials(&[F8(-0.0), F8(0.0)]).await?; - assert!( - ord_ore_cmp(&pool, &p[0], "=", &p[1]).await?, - "-0.0 = +0.0 under block-ORE `_ord_ore` (orderable-bytes canonicalizes the sign of zero)" - ); - Ok(()) + ord_ore_equal::(&pool).await?; + ord_ore_equal::(&pool).await } #[tokio::test] diff --git a/tests/sqlx/tests/encrypted_domain/property/edge_cases.rs b/tests/sqlx/tests/encrypted_domain/property/edge_cases.rs index ee5ca6366..3248e8d65 100644 --- a/tests/sqlx/tests/encrypted_domain/property/edge_cases.rs +++ b/tests/sqlx/tests/encrypted_domain/property/edge_cases.rs @@ -151,14 +151,24 @@ async fn check_rejects_payload_missing_hm(pool: PgPool) -> Result<()> { } #[sqlx::test] -async fn check_rejects_payload_missing_ob(pool: PgPool) -> Result<()> { - // The _ord and _ord_ore domain CHECKs both require `ob`. A payload without - // it must be rejected at the cast on either ordered twin. - let no_ob = r#"{"v":3,"i":{"t":"edge","c":"payload"},"c":"AAAA","hm":"deadbeef"}"#; - for variant in [Variant::Ord, Variant::OrdOre] { - let d = integer(variant); - let sql = format!("SELECT $1::jsonb::{d}"); - assert_raises(&pool, &sql, &[Some(no_ob)], "violates check constraint").await?; - } - Ok(()) +async fn check_ord_rejects_payload_missing_op(pool: PgPool) -> Result<()> { + // Post CLLW-OPE flip, the `_ord` domain is OPE-backed and its CHECK requires + // `op` (not `ob`). A payload carrying `ob` (and `hm`) but no `op` must be + // rejected at the cast — proving `_ord` genuinely needs the OPE term, not the + // ORE `ob` array it no longer references. + let d = integer(Variant::Ord); + let no_op = r#"{"v":3,"i":{"t":"edge","c":"payload"},"c":"AAAA","hm":"deadbeef","ob":["00"]}"#; + let sql = format!("SELECT $1::jsonb::{d}"); + assert_raises(&pool, &sql, &[Some(no_op)], "violates check constraint").await +} + +#[sqlx::test] +async fn check_ord_ore_rejects_payload_missing_ob(pool: PgPool) -> Result<()> { + // The `_ord_ore` domain is ORE-backed and its CHECK requires the `ob` array. + // A payload carrying `op` (and `hm`) but no `ob` must be rejected at the cast + // — proving `_ord_ore` genuinely needs the ORE term, not the OPE `op` scalar. + let d = integer(Variant::OrdOre); + let no_ob = r#"{"v":3,"i":{"t":"edge","c":"payload"},"c":"AAAA","hm":"deadbeef","op":"00"}"#; + let sql = format!("SELECT $1::jsonb::{d}"); + assert_raises(&pool, &sql, &[Some(no_ob)], "violates check constraint").await } diff --git a/tests/sqlx/tests/encrypted_domain/property/fixture_oracle.rs b/tests/sqlx/tests/encrypted_domain/property/fixture_oracle.rs index 410732855..830147632 100644 --- a/tests/sqlx/tests/encrypted_domain/property/fixture_oracle.rs +++ b/tests/sqlx/tests/encrypted_domain/property/fixture_oracle.rs @@ -492,4 +492,18 @@ mod text_fn { }) .await } + + /// `text_search_ore` ([Hm, Ore, Bloom]) — the ORE twin of `text_search`. Same + /// eq/ord function facets plus eq_term + ord_term_ore identity, but ordering + /// rides the block-ORE term (`ord_term_ore`/`ob`) instead of the OPE term + /// (`ord_term`/`op`). The bloom `@>`/`<@` facet is covered by `match_smoke`. + #[sqlx::test] + async fn search_ore_fn_oracle(pool: PgPool) -> Result<()> { + run_fn_property::(pool, 32, |pool, c| async move { + assert_eq_fn_oracle::(&pool, Variant::SearchOre, &c).await?; + assert_ord_fn_oracle::(&pool, Variant::SearchOre, &c).await?; + assert_extractor_oracle::(&pool, Variant::SearchOre, &c).await + }) + .await + } } diff --git a/tests/sqlx/tests/v3_ore_fallback_tests.rs b/tests/sqlx/tests/v3_ore_fallback_tests.rs index 7295e86b6..b6e2b6e55 100644 --- a/tests/sqlx/tests/v3_ore_fallback_tests.rs +++ b/tests/sqlx/tests/v3_ore_fallback_tests.rs @@ -304,17 +304,21 @@ async fn superuser_install_creates_opclass_and_poisons_nothing(pool: PgPool) -> "a superuser install must not poison any domain" ); - let ord = eql_domains::scalar_families() + // Re-point at the ORE domain: `_ord` is OPE (UNPOISONABLE by construction), + // so casting into it proves nothing about the superuser path. `_ord_ore` is + // the poisonable ORE domain — on a superuser install it must NOT be poisoned + // and must accept values, making this a meaningful positive control. + let ord_ore = eql_domains::scalar_families() .find(|s| s.name == "integer") - .and_then(|s| s.domains.iter().find(|d| d.name == "ord")) - .expect("integer_ord in catalog"); + .and_then(|s| s.domains.iter().find(|d| d.name == "ord_ore")) + .expect("integer_ord_ore in catalog"); try_cast( &pool, - "public.eql_v3_integer_ord", - &column_payload(ord.terms), + "public.eql_v3_integer_ord_ore", + &column_payload(ord_ore.terms), ) .await - .expect("integer_ord accepts values on a superuser install"); + .expect("integer_ord_ore accepts values on a superuser install"); Ok(()) } diff --git a/tests/sqlx/tests/v3_privilege_tests.rs b/tests/sqlx/tests/v3_privilege_tests.rs index 3129d75de..cbdaa0dbf 100644 --- a/tests/sqlx/tests/v3_privilege_tests.rs +++ b/tests/sqlx/tests/v3_privilege_tests.rs @@ -44,6 +44,16 @@ const ORD_QUERY: &str = "SELECT count(*) FROM fixtures.eql_v3_integer a, fixtures.eql_v3_integer b \ WHERE a.payload::public.eql_v3_integer_ord < b.payload::public.eql_v3_integer_ord"; +/// The block-ORE counterpart of [`ORD_QUERY`]: the `<` *operator* on +/// `integer_ord_ore`, dispatching through `eql_v3.lt` → `eql_v3.ord_term_ore` → +/// the `eql_v3_internal.ore_block_256` comparator, whose comparison calls +/// pgcrypto `encrypt()` (resolved through the `extensions` schema via the +/// comparator's `SET search_path = pg_catalog, extensions, public`). Unlike the +/// CLLW-OPE `ORD_QUERY`, this path needs USAGE on `extensions`. +const ORD_ORE_QUERY: &str = + "SELECT count(*) FROM fixtures.eql_v3_integer a, fixtures.eql_v3_integer b \ + WHERE a.payload::public.eql_v3_integer_ord_ore < b.payload::public.eql_v3_integer_ord_ore"; + /// A real aggregate (`eql_v3.min` on `integer_ord`). The public aggregate dispatches /// into its state function `eql_v3_internal.min_sfunc`, so it requires the /// internal grant. @@ -155,6 +165,27 @@ fn assert_insufficient_privilege(err: sqlx::Error, context: &str) { ); } +/// Assert a query failed at the pgcrypto / `extensions` boundary: a database +/// error whose message names pgcrypto's `encrypt` or the `extensions` schema. +/// +/// The ORE comparator calls `encrypt()` unqualified, resolved through its +/// `SET search_path = pg_catalog, extensions, public`. When the caller lacks +/// USAGE on `extensions`, PostgreSQL skips that schema during name resolution, +/// so this surfaces as `undefined_function` ("function encrypt(...) does not +/// exist") rather than a plain `permission denied for schema extensions` +/// (`insufficient_privilege`). Both name the boundary, so the assertion pins the +/// message reference, not the exact SQLSTATE. +fn assert_pgcrypto_boundary_error(err: sqlx::Error, context: &str) { + let db_err = err + .as_database_error() + .unwrap_or_else(|| panic!("{context}: expected a database error, got: {err:?}")); + let msg = db_err.message().to_ascii_lowercase(); + assert!( + msg.contains("encrypt") || msg.contains("extensions"), + "{context}: expected an error naming the pgcrypto `encrypt` / `extensions` boundary, got: {db_err:?}" + ); +} + // ============================================================================ // Scalar operator surface // ============================================================================ @@ -239,6 +270,55 @@ async fn runtime_role_without_internal_grant_is_denied(pool: PgPool) -> Result<( Ok(()) } +/// Boundary (OPE vs ORE): a runtime role granted USAGE + EXECUTE on BOTH EQL +/// schemas and read on the fixture — but deliberately NOT USAGE on `extensions` +/// (pgcrypto) — can run the default CLLW-OPE ordering path (`_ord`) yet is denied +/// the block-ORE ordering path (`_ord_ore`). Pins the pgcrypto boundary that +/// motivates preferring `_ord`: the OPE comparator (`eql_v3_internal.ope_cllw`) +/// compares hex-decoded `bytea` natively and never touches pgcrypto, so it needs +/// no `extensions` grant; the ORE comparator (`eql_v3_internal.ore_block_256`) +/// calls pgcrypto `encrypt()` (resolved through `extensions`), so under the +/// identical grant set the same `<` query fails at the crypto call. +/// +/// The positive `runtime_role_with_both_schema_grants_can_query` already runs +/// `_ord` without an `extensions` grant; this adds the contrasting ORE denial +/// under the SAME grants, so the two ordering paths are proven to diverge on +/// exactly the `extensions` grant — not on anything else. +#[sqlx::test(fixtures(path = "../fixtures", scripts("eql_v3_integer")))] +async fn runtime_role_ope_ok_ore_needs_extensions(pool: PgPool) -> Result<()> { + let mut conn = pool.acquire().await?; + let role = create_isolated_role(&mut conn).await?; + + grant_fixture_access(&mut conn, &role, &["eql_v3_integer"]).await?; + grant_schema(&mut conn, &role, "eql_v3").await?; + grant_schema(&mut conn, &role, "eql_v3_internal").await?; + // Deliberately NO grant on `extensions` (pgcrypto) — the whole point: it is + // what separates the OPE path (below, allowed) from the ORE path (denied). + + sqlx::query(&format!("SET ROLE \"{role}\"")) + .execute(&mut *conn) + .await?; + + // (a) The CLLW-OPE `_ord` ordering path succeeds without the extensions grant. + let ope_pairs: i64 = sqlx::query_scalar(ORD_QUERY).fetch_one(&mut *conn).await?; + assert!( + ope_pairs > 0, + "the CLLW-OPE `_ord` ordering path must succeed without an `extensions` grant" + ); + + // (b) The block-ORE `_ord_ore` ordering path is denied: its comparator calls + // pgcrypto `encrypt()` in `extensions`, which this role cannot reach. + let err = sqlx::query(ORD_ORE_QUERY) + .fetch_one(&mut *conn) + .await + .expect_err("the block-ORE `_ord_ore` path must fail without an `extensions` grant"); + assert_pgcrypto_boundary_error(err, "ore ordering without extensions grant"); + + sqlx::query("RESET ROLE").execute(&mut *conn).await?; + drop_role(&mut conn, &role).await?; + Ok(()) +} + // ============================================================================ // jsonb (SteVec) surface — read and write/validate paths avoid eql_v3_internal // ============================================================================ From fa31d49e55c82d41138fd857aa90578421c44ca3 Mon Sep 17 00:00:00 2001 From: James Sadler Date: Tue, 14 Jul 2026 17:06:30 +1000 Subject: [PATCH 17/19] ci(splinter): drop 10 stale ore_cllw allowlist rows, add unused-row check (CIP-3489) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The CLLW-OPE migration removed the `ore_cllw` surface, but its splinter allowlist rows survived and nothing could catch them: the awk only tested `if (key in allow)` per finding and never iterated `allow[]`, so no allowlist row could ever be reported as unused — a future `ore_cllw` would arrive pre-waived. - Remove the 10 inert rows: eql_v3_internal.ore_cllw_{eq,neq,lt,lte,gt,gte} and eql_v3.{ore_cllw,has_ore_cllw} + eql_v3_internal.{ore_cllw,has_ore_cllw}. No such functions exist in src/v3 any more, so the rows waived nothing. - Fix regressed prose on the two live rows that still routed "via ore_cllw": eql_v3.lt (jsonb_entry lt now routes ord_term → ope_cllw) and eql_v3.-> (the chained ste_vec recipe extracts via eq_term / ord_term). - Add a `for (k in allow)` unused-row check: allowlist rows that match no finding now fail the gate (with a CI step-summary section), enforcing the same "registered but referenced by nothing" invariant the known-failures gate uses. Comment/blank heredoc lines are skipped so they are never counted as unused. Verified end-to-end against a live install (splinter@55db5b1): the gate stays clean (raw=1180, allowlisted=1180, unmatched=0, unused=0, exit 0) after the row removals, and an injected bogus row is correctly reported unused and fails the gate (exit 1). --- tasks/test/splinter.sh | 60 ++++++++++++++++++++++++++++++------------ 1 file changed, 43 insertions(+), 17 deletions(-) diff --git a/tasks/test/splinter.sh b/tasks/test/splinter.sh index a88818821..f34186a27 100755 --- a/tasks/test/splinter.sh +++ b/tasks/test/splinter.sh @@ -31,6 +31,7 @@ splinter_sql="$work_dir/splinter.sql" all_findings_tsv="$work_dir/all_findings.tsv" findings_tsv="$work_dir/findings.tsv" allowlisted_tsv="$work_dir/allowlisted.tsv" +unused_allow_tsv="$work_dir/unused_allow.tsv" summary_by_rule="$work_dir/by_rule.tsv" echo "Fetching splinter@${SPLINTER_SHA}..." @@ -68,7 +69,7 @@ function_search_path_mutable eql_v3 match_term function Bloom-filter match term function_search_path_mutable eql_v3 matches function Bloom fuzzy-match (@@) comparison wrapper on the public *_match domains — the public function-form equivalent of @@ (callable without the operator on Supabase/PostgREST); the CREATE OPERATOR also lives in eql_v3. Inlines to `match_term(a) @> match_term(b)` (bloom array-containment on the extracted terms); must reach the functional GIN index on eql_v3.match_term(col) for bloom-filter match to engage Bitmap Index Scan. (Renamed from eql_v3.contains — CIP-3517; @>/<@ are containment, not the match, and now raise on the *_match domains.) function_search_path_mutable eql_v3 eq function Equality comparison wrapper on the public domains — the public function-form equivalent of = (callable without the operator). Inlines to `eq_term(a) = eq_term(b)`; must reach the functional index on eql_v3.eq_term(col) for bare-form equality to engage Index Scan. Covers the converged eq wrappers on the public scalar variants, and the jsonb_entry eq wrapper (jsonb/operators.sql) which shares the same (schema, name, type) key. function_search_path_mutable eql_v3 neq function Inequality comparison wrapper on the public domains — public function-form equivalent of <>. Same rationale as eql_v3.eq. -function_search_path_mutable eql_v3 lt function Less-than comparison wrapper on the public ordered domains — public function-form equivalent of <. Inlines to `ord_term(a) < ord_term(b)`; must reach the functional btree index on eql_v3.ord_term(col) for range queries to engage Index Scan. Also covers the jsonb_entry lt wrapper (via ore_cllw), which shares the same (schema, name, type) key. +function_search_path_mutable eql_v3 lt function Less-than comparison wrapper on the public ordered domains — public function-form equivalent of <. Inlines to `ord_term(a) < ord_term(b)`; must reach the functional btree index on eql_v3.ord_term(col) for range queries to engage Index Scan. Also covers the jsonb_entry lt wrapper (via ord_term → ope_cllw), which shares the same (schema, name, type) key. function_search_path_mutable eql_v3 lte function Less-than-or-equal comparison wrapper on the public ordered domains — public function-form equivalent of <=. Same rationale as eql_v3.lt. function_search_path_mutable eql_v3 gt function Greater-than comparison wrapper on the public ordered domains — public function-form equivalent of >. Same rationale as eql_v3.lt. function_search_path_mutable eql_v3 gte function Greater-than-or-equal comparison wrapper on the public ordered domains — public function-form equivalent of >=. Same rationale as eql_v3.lt. @@ -84,12 +85,6 @@ function_search_path_mutable eql_v3_internal hmac_256 function HMAC equality ext function_search_path_mutable eql_v3_internal bloom_filter function Bloom-filter match extractor for the eql_v3 SEM fork (now in eql_v3_internal): inlinable SQL (jsonb) constructor used inside eql_v3.match_term. Must inline so the functional GIN index on eql_v3.match_term(col) engages. Mirrors eql_v3_internal.hmac_256. function_search_path_mutable eql_v3_internal jsonb_array_to_bytea_array function Hand-written jsonb→bytea[] helper for the eql_v3 SEM fork (now in eql_v3_internal): inlinable SQL (no SET, IMMUTABLE). Reached per-encrypted-value through eql_v3_internal.ore_block_256; must inline so the planner can fold it into the calling query. Pinned by neither the structural skip (it takes bare jsonb, not a jsonb-backed domain) nor an inline-critical OID clause — it carries the documented `eql-inline-critical` COMMENT marker that tasks/pin_search_path_v3.sql honours. function_search_path_mutable eql_v3_internal jsonb_array_to_ore_block_256 function Hand-written jsonb→ore_block composite helper for the eql_v3 SEM fork (now in eql_v3_internal): inlinable SQL (no SET, IMMUTABLE). Same rationale as eql_v3_internal.jsonb_array_to_bytea_array — reached per-encrypted-value through eql_v3_internal.ore_block_256, carries the `eql-inline-critical` COMMENT marker. -function_search_path_mutable eql_v3_internal ore_cllw_eq function Inner comparator for the eql_v3_internal.ore_cllw composite type's `=` operator (self-contained SEM fork, DEFAULT FOR TYPE btree opclass eql_v3_internal.ore_cllw_ops). The outer same-type operators back the opclass; the planner only carries the inlined form through to functional-index match if this inner function is also inlinable (no SET, IMMUTABLE). The plpgsql FUNCTION 1 comparator (compare_ore_cllw_term) stays pinned by design. -function_search_path_mutable eql_v3_internal ore_cllw_neq function Inner comparator for the eql_v3_internal.ore_cllw `<>` operator. Same rationale as eql_v3_internal.ore_cllw_eq. -function_search_path_mutable eql_v3_internal ore_cllw_lt function Inner comparator for the eql_v3_internal.ore_cllw `<` operator. Same rationale as eql_v3_internal.ore_cllw_eq. -function_search_path_mutable eql_v3_internal ore_cllw_lte function Inner comparator for the eql_v3_internal.ore_cllw `<=` operator. Same rationale as eql_v3_internal.ore_cllw_eq. -function_search_path_mutable eql_v3_internal ore_cllw_gt function Inner comparator for the eql_v3_internal.ore_cllw `>` operator. Same rationale as eql_v3_internal.ore_cllw_eq. -function_search_path_mutable eql_v3_internal ore_cllw_gte function Inner comparator for the eql_v3_internal.ore_cllw `>=` operator. Same rationale as eql_v3_internal.ore_cllw_eq. function_search_path_mutable eql_v3 ord_term function CLLW-OPE order term extractor for the public *_ord / *_ord_ope domains: returns eql_v3_internal.ope_cllw, a domain over bytea that inherits the native bytea comparison operators and DEFAULT btree opclass. Used inside the inlinable comparison wrappers and as the functional-index expression USING btree (eql_v3.ord_term(col)); must inline so the whole chain folds to native bytea comparisons the index can match. OPE backs the default _ord domain, so it takes the unqualified extractor name; block-ORE takes ord_term_ore. One overload per *_ord / *_ord_ope domain. function_search_path_mutable eql_v3_internal ope_cllw function CLLW-OPE extractor for the eql_v3 SEM fork (now in eql_v3_internal): inlinable SQL (jsonb) constructor used inside eql_v3.ord_term, hex-decoding `op` to the bytea-backed eql_v3_internal.ope_cllw domain. The domain inherits bytea's native comparison operators and btree opclass, so the WHOLE comparison chain (wrapper -> ord_term -> this) is inlinable SQL and the functional btree index on eql_v3.ord_term(col) engages structurally — the hmac_256 pattern. Carries the `eql-inline-critical` COMMENT marker (bare jsonb arg escapes the structural domain-arg skip). # Encrypted-JSONB document surface (src/v3/jsonb): the hand-written public.eql_v3_json / @@ -99,14 +94,10 @@ function_search_path_mutable eql_v3_internal ope_cllw function CLLW-OPE extracto # the structural jsonb-domain-arg skip or the documented `eql-inline-critical` # COMMENT marker (the plpgsql blockers in blockers.sql are pinned and do not # surface). Splinter matches by (schema, name, type), so they need their own rows. -function_search_path_mutable eql_v3 -> function Typed sv-element selector lookup on the eql_v3 encrypted-JSONB surface: inlinable SQL over a public.eql_v3_json domain arg so `col -> ''` folds into the calling query, preserving functional-index match for the chained ste_vec recipes (eq_term / ore_cllw on the extracted entry). Left unpinned by the structural domain-arg skip in pin_search_path_v3.sql. Two overloads: (json, text), (json, int). +function_search_path_mutable eql_v3 -> function Typed sv-element selector lookup on the eql_v3 encrypted-JSONB surface: inlinable SQL over a public.eql_v3_json domain arg so `col -> ''` folds into the calling query, preserving functional-index match for the chained ste_vec recipes (eq_term / ord_term on the extracted entry). Left unpinned by the structural domain-arg skip in pin_search_path_v3.sql. Two overloads: (json, text), (json, int). function_search_path_mutable eql_v3 ->> function Text sv-element selector lookup on the eql_v3 encrypted-JSONB surface: inlinable SQL over a public.eql_v3_json domain arg, text-returning counterpart to eql_v3.->. Structural domain-arg skip. Two overloads: (json, text), (json, int). function_search_path_mutable eql_v3 @> function Containment (@>) operator wrapper on the eql_v3 encrypted-JSONB surface: inlinable SQL so the planner can match the functional GIN index on eql_v3.to_ste_vec_query(col)::jsonb. Structural domain-arg skip (public.eql_v3_json). Three overloads. function_search_path_mutable eql_v3 <@ function Contained-by (<@) operator wrapper on the eql_v3 encrypted-JSONB surface: same rationale as eql_v3.@>. Three overloads. -function_search_path_mutable eql_v3 ore_cllw function ORE-CLLW extractor on the eql_v3 encrypted-JSONB surface: inlinable SQL so `eql_v3.ore_cllw(col -> 'sel')` folds into the calling query and reaches the functional btree opclass on eql_v3_internal.ore_cllw. Structural domain-arg skip. Single (public.eql_v3_jsonb_entry) overload — the (jsonb) SEM-fork overload moved to eql_v3_internal.ore_cllw (its own allowlist row below). -function_search_path_mutable eql_v3 has_ore_cllw function ORE-CLLW presence check on the eql_v3 encrypted-JSONB surface: inlinable SQL counterpart to eql_v3.ore_cllw, structural domain-arg skip. Single (public.eql_v3_jsonb_entry) overload — the (jsonb) SEM-fork overload moved to eql_v3_internal.has_ore_cllw. -function_search_path_mutable eql_v3_internal ore_cllw function ORE-CLLW constructor for the eql_v3 SEM fork (now in eql_v3_internal): inlinable SQL (jsonb) constructor. Takes bare jsonb, not a jsonb-backed domain, so it is left unpinned via the explicit inline-critical OID clause in pin_search_path_v3.sql (mirrors eql_v3_internal.hmac_256/bloom_filter) rather than the structural skip. Distinct from the eql_v3.ore_cllw(jsonb_entry) extractor overload, which stays public. -function_search_path_mutable eql_v3_internal has_ore_cllw function ORE-CLLW presence check for the eql_v3 SEM fork (now in eql_v3_internal): inlinable SQL (jsonb) counterpart to eql_v3_internal.ore_cllw. Same inline-critical OID rationale. Distinct from the eql_v3.has_ore_cllw(jsonb_entry) overload, which stays public. function_search_path_mutable eql_v3 selector function STE-vec entry selector extractor: typed (public.eql_v3_jsonb_entry) overload, inlinable so `eql_v3.selector(col -> 'sel')` folds into the calling query. Structural domain-arg skip. The (jsonb) overload is plpgsql with a pinned search_path and does not surface. function_search_path_mutable eql_v3 to_ste_vec_query function Encrypted-JSONB query-document constructor (CAST WITH FUNCTION for 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_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. @@ -153,27 +144,44 @@ fi # Split: allowlisted entries match all of (rule, schema, name, type). # Use FILENAME as the discriminator rather than NR == FNR so behavior is # robust to either file being empty. +# +# The END block also emits allowlist rows that matched NO finding. An allowlist +# row is a standing waiver; once the function it covers is gone (e.g. the +# `ore_cllw` surface removed in the CLLW-OPE migration) the row is dead weight +# that would silently pre-waive a future re-introduction. Reporting unused rows +# enforces the same "registered but referenced by nothing" invariant the +# known-failures gate applies to suppressed tests. Comment (`#…`) and blank lines +# in the allowlist heredoc are skipped so they are never counted as unused rows. awk -F'\t' \ -v allowlist_file="$work_dir/allowlist.tsv" \ -v allow_out="$allowlisted_tsv" \ - -v deny_out="$findings_tsv" ' + -v deny_out="$findings_tsv" \ + -v unused_out="$unused_allow_tsv" ' FILENAME == allowlist_file { + if (NF < 5 || $1 ~ /^[[:space:]]*#/) next key = $1 SUBSEP $2 SUBSEP $3 SUBSEP $4 allow[key] = $5 + allow_desc[key] = $1 "\t" $2 "\t" $3 "\t" $4 next } { key = $1 SUBSEP $4 SUBSEP $5 SUBSEP $6 if (key in allow) { + used[key] = 1 print $0 "\t" allow[key] > allow_out } else { print $0 > deny_out } } + END { + for (k in allow) + if (!(k in used)) + print allow_desc[k] > unused_out + } ' "$work_dir/allowlist.tsv" "$all_findings_tsv" -# Touch in case awk didn't write either file (no findings at all). -touch "$findings_tsv" "$allowlisted_tsv" +# Touch in case awk didn't write a file (no findings, or no unused rows). +touch "$findings_tsv" "$allowlisted_tsv" "$unused_allow_tsv" # Summary scoped to the same schemas the gate considers, so the count line # matches what was actually checked. @@ -192,6 +200,7 @@ SQL raw_total="$(wc -l < "$all_findings_tsv" | tr -d ' ')" allowlisted_total="$(wc -l < "$allowlisted_tsv" | tr -d ' ')" +unused_total="$(wc -l < "$unused_allow_tsv" | tr -d ' ')" total="$(wc -l < "$findings_tsv" | tr -d ' ')" errors="$(awk -F'\t' '$2 == "ERROR"' "$findings_tsv" | wc -l | tr -d ' ')" warns="$(awk -F'\t' '$2 == "WARN"' "$findings_tsv" | wc -l | tr -d ' ')" @@ -215,6 +224,12 @@ if [[ "$total" -gt 0 ]]; then awk -F'\t' '{ printf " - [%s] %s — %s\n", $2, $1, $3 }' "$findings_tsv" fi +if [[ "$unused_total" -gt 0 ]]; then + echo + echo "Allowlist rows that matched NO finding (stale — remove them from tasks/test/splinter.sh):" + awk -F'\t' '{ printf " - [%s] %s.%s (%s)\n", $1, $2, $3, $4 }' "$unused_allow_tsv" +fi + # Write a GitHub Actions step summary if we're in CI. if [[ -n "${GITHUB_STEP_SUMMARY:-}" ]]; then { @@ -242,6 +257,16 @@ if [[ -n "${GITHUB_STEP_SUMMARY:-}" ]]; then echo "EQL is splinter-clean (all findings covered by the allowlist)." echo fi + if [[ "$unused_total" -gt 0 ]]; then + echo "### Stale allowlist rows (action required)" + echo + echo "These allowlist rows matched no splinter finding — the function they waived is gone. Remove them from \`tasks/test/splinter.sh\`." + echo + echo "| Rule | Schema | Name | Type |" + echo "| --- | --- | --- | --- |" + awk -F'\t' '{ printf "| `%s` | `%s` | `%s` | %s |\n", $1, $2, $3, $4 }' "$unused_allow_tsv" + echo + fi if [[ "$allowlisted_total" -gt 0 ]]; then echo "
Allowlisted findings (${allowlisted_total})" echo @@ -257,7 +282,8 @@ if [[ -n "${GITHUB_STEP_SUMMARY:-}" ]]; then } >> "$GITHUB_STEP_SUMMARY" fi -# Fail only on findings that aren't allowlisted. -if [[ "$total" -gt 0 ]]; then +# Fail on unmatched findings OR on stale (unused) allowlist rows — both are +# drift the gate exists to catch. +if [[ "$total" -gt 0 || "$unused_total" -gt 0 ]]; then exit 1 fi From 49ef5418f11b78f4a702577fb1eb3e5507b4cb8f Mon Sep 17 00:00:00 2001 From: James Sadler Date: Tue, 14 Jul 2026 16:59:42 +1000 Subject: [PATCH 18/19] ci(known-failures): close four fail-open / false-positive paths (CIP-3488) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The known-failure gate could report success while verifying nothing, or fail with the wrong reason. Four independent defects, all raised in review on #389 and still live on main: - T14 (fail-open): the registry parser was fully anchored and hardcoded `u64`; any deviation (u32, indentation, a trailing comment, `1_000`) parsed zero rows, printed "nothing to verify", and exit 0. Now the strict parse is tolerant of indentation / trailing comments / `_` digit separators, and a declared-vs-parsed mismatch (counted independently with a loose matcher) is a hard error (exit 2). - T3 (transient reads as missing): switched from `gh issue view … || echo MISSING` to `gh api repos//issues/`, classifying a genuine `(HTTP 404)` as NOT_FOUND and every other gh/network error as a distinct transient ERROR, so a network blip no longer masquerades as "issue missing". - T15 (PR numbers pass as issues): the REST issues object carries a `pull_request` key iff the number is a PR; PR numbers are now rejected instead of validating as open issues. - T16 (bash 3.2): replaced `mapfile` (bash 4+) with a 3.2-safe while-read loop — mise invokes this as `bash …` and stock macOS /bin/bash is 3.2. Verified end-to-end against the live registry and crafted fixtures (u32 drift → exit 2; PR #399 → rejected; missing #99999999 → NOT_FOUND; `3_87` + indentation + comment → parsed 387, OPEN), and under /bin/bash 3.2.57. --- tasks/test/known-failures.sh | 118 +++++++++++++++++++++++++++++++---- 1 file changed, 105 insertions(+), 13 deletions(-) diff --git a/tasks/test/known-failures.sh b/tasks/test/known-failures.sh index 63881dbff..b5430f1f4 100755 --- a/tasks/test/known-failures.sh +++ b/tasks/test/known-failures.sh @@ -14,6 +14,10 @@ # you cannot keep suppressing it once the bug is closed. # # Needs `gh` authenticated (CI: GITHUB_TOKEN). Read-only. +# +# Portability: targets bash 3.2 (stock macOS /bin/bash), since mise.toml invokes +# this as `bash tasks/test/known-failures.sh`. No `mapfile`, no other bash-4 +# features. set -euo pipefail EQL_ROOT="${EQL_ROOT:-$(git rev-parse --show-toplevel)}" @@ -25,17 +29,89 @@ REGISTRY="${EQL_ROOT}/tests/sqlx/src/known_failure.rs" repo=$(sed -n 's/^pub const KNOWN_FAILURE_REPO: &str = "\(.*\)";$/\1/p' "$REGISTRY") [ -n "$repo" ] || { echo "could not read KNOWN_FAILURE_REPO from $REGISTRY" >&2; exit 2; } -# Every `pub const ISSUE_: u64 = ;` in the registry. -mapfile -t entries < <( - sed -n 's/^pub const \(ISSUE_[A-Z0-9_]*\): u64 = \([0-9]*\);$/\1 \2/p' "$REGISTRY" +# Count declarations with a LOOSE matcher (anything that reads as an `ISSUE_*` +# constant), independently of the strict parse below. If the strict parse +# recovers FEWER rows than were declared, the format drifted (a `u32`, a renamed +# type, a malformed line) and the strict regex would silently skip markers. A +# gate that parses zero rows and exits 0 is the exact fail-open this check exists +# to prevent, so a declared-vs-parsed mismatch is a hard error, never a pass. +declared=$(grep -cE '^[[:space:]]*pub const ISSUE_[A-Za-z0-9_]+[[:space:]]*:' "$REGISTRY" || true) + +# Strict parse: `pub const ISSUE_: u64 = ;` → " ". Tolerant of +# leading indentation, a trailing line comment, and `_` digit separators so that +# benign formatting is not mistaken for drift; the type must still be `u64`. +# bash 3.2-safe accumulation (no `mapfile`): a while-read loop over a process +# substitution runs in the current shell, so the array persists after the loop. +entries=() +while IFS= read -r line; do + entries+=("$line") +done < <( + sed -n -E \ + 's/^[[:space:]]*pub const (ISSUE_[A-Z0-9_]+)[[:space:]]*:[[:space:]]*u64[[:space:]]*=[[:space:]]*([0-9_]+)[[:space:]]*;.*$/\1 \2/p' \ + "$REGISTRY" ) +parsed=${#entries[@]} -if [ "${#entries[@]}" -eq 0 ]; then +if [ "$declared" -ne "$parsed" ]; then + echo "known-failure gate: parsed ${parsed} of ${declared} declared ISSUE_ constant(s)." >&2 + echo ' The strict `pub const ISSUE_: u64 = ;` parser skipped a declaration —' >&2 + echo " a format change (wrong type, malformed line) would let a marker slip past this" >&2 + echo " gate unverified. Fix the declaration or this parser; refusing to run." >&2 + exit 2 +fi + +if [ "$parsed" -eq 0 ]; then echo "==> no known-failure markers registered — nothing to verify." exit 0 fi -echo "==> verifying ${#entries[@]} known-failure marker(s) against ${repo}" +echo "==> verifying ${parsed} known-failure marker(s) against ${repo}" + +# Classify one issue number via the REST issues endpoint. Prints exactly one of +# OPEN | CLOSED | PULL_REQUEST | NOT_FOUND | ERROR: +# on stdout, and never itself exits non-zero (the caller decides pass/fail). +# +# Using `gh api repos//issues/` — rather than `gh issue view` — closes +# two review findings: +# * T3: a TRANSIENT failure (5xx, rate-limit, unauthenticated, DNS) is +# distinguishable from a genuine 404. `gh api` reports a missing issue as +# `(HTTP 404)` and everything else with a different message, so a network +# blip no longer masquerades as "issue missing" (nor the reverse). +# * T15: issues and PRs share a number space and `gh issue view` happily +# resolves a PR number. The REST issues object carries a `pull_request` key +# iff the number is a PR, so PRs are rejected instead of passing as issues. +classify_number() { + number="$1" + err_file=$(mktemp) + # On HTTP 200 the bundled `--jq` prints "\t"; on any HTTP/network + # error `gh` exits non-zero and writes the reason to stderr (jq is not applied). + if out=$(gh api "repos/${repo}/issues/${number}" \ + --jq '"\(.state)\t\(has("pull_request"))"' 2>"$err_file"); then + rm -f "$err_file" + state="${out%%$'\t'*}" + is_pr="${out##*$'\t'}" + if [ "$is_pr" = "true" ]; then + echo "PULL_REQUEST" + return 0 + fi + case "$state" in + open) echo "OPEN" ;; + closed) echo "CLOSED" ;; + *) echo "ERROR:unexpected issue state '${state}'" ;; + esac + return 0 + fi + + err=$(cat "$err_file"); rm -f "$err_file" + # A definitive 404 is a genuinely missing issue; anything else is transient + # infrastructure and must NOT read as "missing". + if printf '%s' "$err" | grep -qi 'HTTP 404'; then + echo "NOT_FOUND" + else + # Collapse to a single line so the caller's diagnostic stays readable. + echo "ERROR:$(printf '%s' "$err" | tr '\n' ' ' | sed 's/[[:space:]]\{1,\}/ /g')" + fi +} # A marker whose constant is never referenced by a test is dead weight: the bug # may be long fixed and nobody noticed. Catch that too. @@ -43,11 +119,12 @@ fail=0 for entry in "${entries[@]}"; do name=${entry%% *} number=${entry##* } + number=${number//_/} # `1_000` (Rust literal) → 1000 for the API path - # `grep` exits 1 when it matches nothing — which is exactly the case this - # check exists to report. Under `set -e` + `pipefail` that status propagates - # out of the pipeline and kills the script here, before the diagnostic below - # can print. Swallow only grep's status; `wc` still counts the (empty) input. + # `grep` exits 1 when it matches nothing — which is exactly the case this check + # exists to report. Under `set -e` + `pipefail` that status propagates out of + # the pipeline and kills the script here, before the diagnostic below can + # print. Swallow only grep's status; `wc` still counts the (empty) input. refs=$( { grep -rl --include='*.rs' -- "$name" "${EQL_ROOT}/tests/sqlx/tests" 2>/dev/null || true; } | wc -l | tr -d ' ') if [ "$refs" -eq 0 ]; then echo " ✗ ${name} (#${number}) is registered but referenced by no test — remove it" >&2 @@ -55,8 +132,8 @@ for entry in "${entries[@]}"; do continue fi - state=$(gh issue view "$number" --repo "$repo" --json state -q .state 2>/dev/null || echo "MISSING") - case "$state" in + result=$(classify_number "$number") + case "$result" in OPEN) echo " ✓ ${name} → ${repo}#${number} is OPEN (${refs} test ref(s))" ;; @@ -66,11 +143,26 @@ for entry in "${entries[@]}"; do echo " or it was closed in error (reopen it)." >&2 fail=1 ;; - *) - echo " ✗ ${name} → ${repo}#${number} could not be read (state=${state})." >&2 + PULL_REQUEST) + echo " ✗ ${name} → ${repo}#${number} is a PULL REQUEST, not an issue." >&2 + echo " Issues and PRs share a number space; point the marker at the tracking issue." >&2 + fail=1 + ;; + NOT_FOUND) + echo " ✗ ${name} → ${repo}#${number} does not exist." >&2 echo " A known-failure marker must name a real issue." >&2 fail=1 ;; + ERROR:*) + echo " ✗ ${name} → ${repo}#${number} could not be verified (${result#ERROR:})." >&2 + echo " This looks like a transient GitHub/network error, not a missing issue —" >&2 + echo " re-run the gate; if it persists, check gh auth / GitHub status." >&2 + fail=1 + ;; + *) + echo " ✗ ${name} → ${repo}#${number}: unexpected classifier result '${result}'." >&2 + fail=1 + ;; esac done From aacb4a50f3ebd40c4e0f5e70d1f3a3d772126ba8 Mon Sep 17 00:00:00 2001 From: James Sadler Date: Fri, 17 Jul 2026 16:53:05 +1000 Subject: [PATCH 19/19] test(sqlx): size the test Postgres lock table for concurrent uninstalls MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The merge queue ejects PRs when the sqlx shards fail with `53200 out of shared memory`. Despite the wording this is not RAM exhaustion — it is the shared lock table running out of slots, exactly as the error's own hint ("You might need to increase max_locks_per_transaction") says. max_locks_per_transaction is not a per-transaction cap; it sizes the CLUSTER-WIDE lock table as max_locks_per_transaction * max_connections. The shipped uninstaller drops both eql_v3 schemas with DROP ... CASCADE, which locks every one of the ~5,682 objects it removes and holds them all until commit (sqlx::raw_sql sends the script as one implicit transaction). Measured: 5,689 locks for a single uninstall against a stock table of 64 * 100 = 6,400 slots — 89% of the entire cluster's budget in one transaction. Overlapping uninstalls exhaust it, and the backends that then fail are mostly innocent tests that were merely installing EQL, which is why this surfaces as `failed to apply migrations` in unrelated tests. Sharding is what tipped it over: the queue runs 2 shards where PRs run 4, doubling test density per shard so the uninstall-heavy tests overlap. Partitioning is a deterministic hash, so they land in the same shard on every run — hence shard 2/2 failing on all four PG versions while the same commit passes on the PR. This is not specific to one PR: #382, #401 and #402 ejected with the identical signature. Raise max_locks_per_transaction to 1024 (102,400 slots), sized for the worst case of nextest's 16 concurrent tests each uninstalling (~91k locks). Verified on postgres:17: 6 concurrent uninstalls fail 5/6 at the default and pass 6/6 at 1024. Costs ~42MB of shared memory (145MB -> 187MB), well inside the container's 2GB limit. Add lock_capacity_tests.rs as a preflight gate so an undersized lock table fails once, immediately, with a message naming the cause and the fix — instead of six unrelated tests dying 20 minutes into CI with what reads like an OOM. NB: a Postgres container created before this change keeps the old setting, so local devs must recreate it (mise run postgres:down && mise run postgres:up postgres-17). Deliberately not "fixed" by giving the queue 4 shards: that would only hide an undersized lock table until the catalog grew again. --- tests/docker-compose.yml | 14 ++++- tests/sqlx/tests/lock_capacity_tests.rs | 81 +++++++++++++++++++++++++ 2 files changed, 94 insertions(+), 1 deletion(-) create mode 100644 tests/sqlx/tests/lock_capacity_tests.rs diff --git a/tests/docker-compose.yml b/tests/docker-compose.yml index fdf3b7b56..e38594f59 100644 --- a/tests/docker-compose.yml +++ b/tests/docker-compose.yml @@ -2,7 +2,19 @@ services: postgres: &postgres container_name: postgres image: postgres:17 - command: postgres -c track_functions=all -c shared_preload_libraries=pg_stat_statements -c pg_stat_statements.track=all + # max_locks_per_transaction is NOT a per-transaction cap — it sizes the + # CLUSTER-WIDE shared lock table as max_locks_per_transaction * + # max_connections. The shipped uninstaller drops both eql_v3 schemas with + # DROP ... CASCADE, which takes a lock on every one of the ~5,700 objects it + # removes and holds them all until commit (sqlx sends the script as a single + # implicit transaction). At the stock 64 * 100 = 6,400 slots, ONE uninstall + # already consumes ~89% of the table, so two concurrent ones exhaust it and + # every backend — including unrelated tests merely installing EQL — fails + # with `53200 out of shared memory`. nextest runs one test per core (16 in + # CI), so size for the worst case: 16 * 5,700 ~= 91k slots. 1024 * 100 = + # 102,400 covers it, and costs ~42MB of shared memory (well inside the 2GB + # limit below). Keep tests/sqlx/tests/lock_capacity_tests.rs in sync. + command: postgres -c track_functions=all -c shared_preload_libraries=pg_stat_statements -c pg_stat_statements.track=all -c max_locks_per_transaction=1024 ports: - 7432:7432 environment: diff --git a/tests/sqlx/tests/lock_capacity_tests.rs b/tests/sqlx/tests/lock_capacity_tests.rs new file mode 100644 index 000000000..080d248f7 --- /dev/null +++ b/tests/sqlx/tests/lock_capacity_tests.rs @@ -0,0 +1,81 @@ +//! Preflight gate: the Postgres shared lock table must be big enough for the +//! suite's concurrent `DROP ... CASCADE` load. +//! +//! Why this exists: the shipped uninstaller drops both `eql_v3` schemas with +//! `DROP ... CASCADE`. That takes a lock on every one of the ~5,700 objects it +//! removes and holds them until the transaction commits — `sqlx::raw_sql` sends +//! the whole script as ONE implicit transaction. `max_locks_per_transaction` is +//! not a per-transaction cap; it sizes the *cluster-wide* shared lock table as +//! `max_locks_per_transaction * max_connections`. At the stock 64 * 100 = 6,400 +//! slots a single uninstall already holds ~89% of the table, so two overlapping +//! ones exhaust it — and the backends that then fail with `53200 out of shared +//! memory` are mostly INNOCENT tests that were merely installing EQL. +//! +//! That failure mode is maximally confusing: a handful of unrelated tests fail +//! ~20 minutes into CI with what reads like an out-of-memory error, and only on +//! whichever shard happened to pack the uninstall-heavy tests together. This +//! test converts it into one immediate, self-explanatory failure naming the +//! cause and the fix. +//! +//! `tests/docker-compose.yml` provisions the capacity (`-c +//! max_locks_per_transaction=1024`); this asserts the database under test +//! actually has it. + +use anyhow::Result; +use eql_tests::property::connect_pool; + +/// Locks held by one full run of the shipped uninstaller, measured against the +/// v3 surface (`DROP ... CASCADE` over ~5,682 objects, plus catalog locks). +/// This grows as the catalog grows — it is a measured floor, not a constant of +/// nature. +const LOCKS_PER_UNINSTALL: i64 = 5_700; + +/// Worst-case simultaneous uninstalls: nextest runs one test per core, and CI +/// runners have 16. Every one of those slots could be an uninstall-heavy test. +const WORST_CASE_CONCURRENT_UNINSTALLS: i64 = 16; + +/// The capacity the suite needs: ~91k slots. The compose setting (1024 * 100 = +/// 102,400) clears this; the stock default (6,400) misses it by ~14x. +const MIN_LOCK_TABLE_CAPACITY: i64 = LOCKS_PER_UNINSTALL * WORST_CASE_CONCURRENT_UNINSTALLS; + +/// Read an integer GUC. Both settings are plain integers with no unit, so +/// `current_setting` parses cleanly. +async fn int_setting(pool: &sqlx::PgPool, name: &str) -> Result { + let raw: String = sqlx::query_scalar(&format!("SELECT current_setting('{name}')")) + .fetch_one(pool) + .await?; + Ok(raw.parse()?) +} + +/// The lock table must hold the suite's worst-case concurrent uninstall load. +/// +/// Asserts on the derived *capacity* rather than on `max_locks_per_transaction` +/// alone, so an operator who reaches the same headroom by a different split +/// (e.g. a larger `max_connections`) still passes. +#[tokio::test] +async fn lock_table_fits_concurrent_uninstalls() -> Result<()> { + let pool = connect_pool().await?; + + let max_locks = int_setting(&pool, "max_locks_per_transaction").await?; + let max_connections = int_setting(&pool, "max_connections").await?; + let capacity = max_locks * max_connections; + + assert!( + capacity >= MIN_LOCK_TABLE_CAPACITY, + "Postgres shared lock table is too small for this suite: \ + max_locks_per_transaction ({max_locks}) * max_connections ({max_connections}) \ + = {capacity} slots, need >= {MIN_LOCK_TABLE_CAPACITY} \ + ({WORST_CASE_CONCURRENT_UNINSTALLS} concurrent uninstalls * \ + ~{LOCKS_PER_UNINSTALL} locks each).\n\ + \n\ + Left unfixed this does NOT fail here — it surfaces later as \ + `53200 out of shared memory` in whichever unrelated tests happen to run \ + alongside an uninstall.\n\ + \n\ + Fix: tests/docker-compose.yml sets `-c max_locks_per_transaction=1024`. \ + A container created before that change keeps the old setting, so recreate it:\n\ + \n mise run postgres:down && mise run postgres:up postgres-17\n" + ); + + Ok(()) +}